Mercurial > iotbalkon / file comparison

comparison: esp-idf-lib/components/apds9930/apds9930.c

esp-idf-lib/components/apds9930/apds9930.c

changeset 17
1599e696d947
parent 16
b3e96bbe4ce4
child 21
df8564c9701e
equal deleted inserted replaced
16:b3e96bbe4ce4 17:1599e696d947
179 APDS9930_ID_1, APDS9930_ID_2, APDS9930_ID_3, dev->id); 179 APDS9930_ID_1, APDS9930_ID_2, APDS9930_ID_3, dev->id);
180 } 180 }
181 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 181 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
182 182
183 /* Set ENABLE register to 0 (disable all features) */ 183 /* Set ENABLE register to 0 (disable all features) */
184 if (apds9930_setMode(dev, APDS9930_MODE_ALL, APDS9930_OFF) != ESP_OK) { 184 if (apds9930_setMode(dev, APDS9930_MODE_ALL | APDS9930_AUTO_INCREMENT, APDS9930_OFF) != ESP_OK) {
185 ESP_LOGE(TAG, "apds9930_init() error 'Regs off'"); 185 ESP_LOGE(TAG, "apds9930_init() error 'Regs off'");
186 err = ESP_ERR_INVALID_ARG; 186 err = ESP_ERR_INVALID_ARG;
187 } 187 }
188 188
189 /* Set default values for ambient light and proximity registers */ 189 /* Set default values for ambient light and proximity registers */
190 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 190 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
191 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_ATIME, APDS9930_DEFAULT_ATIME), "Default atime"); 191 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_ATIME | APDS9930_AUTO_INCREMENT, APDS9930_DEFAULT_ATIME), "Default atime");
192 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_WTIME, APDS9930_DEFAULT_WTIME), "Default wtime"); 192 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_WTIME | APDS9930_AUTO_INCREMENT, APDS9930_DEFAULT_WTIME), "Default wtime");
193 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_PPULSE, APDS9930_DEFAULT_PPULSE), "Default ppulse"); 193 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_PPULSE | APDS9930_AUTO_INCREMENT, APDS9930_DEFAULT_PPULSE), "Default ppulse");
194 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_POFFSET, APDS9930_DEFAULT_POFFSET), "Default poffset"); 194 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_POFFSET | APDS9930_AUTO_INCREMENT, APDS9930_DEFAULT_POFFSET), "Default poffset");
195 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_CONFIG, APDS9930_DEFAULT_CONFIG), "Default config"); 195 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_CONFIG | APDS9930_AUTO_INCREMENT, APDS9930_DEFAULT_CONFIG), "Default config");
196 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 196 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
197 197
198 CHECK_LOGE(dev, apds9930_setLEDDrive(dev, APDS9930_DEFAULT_PDRIVE), "Default pdrive"); 198 CHECK_LOGE(dev, apds9930_setLEDDrive(dev, APDS9930_DEFAULT_PDRIVE), "Default pdrive");
199 CHECK_LOGE(dev, apds9930_setProximityGain(dev, APDS9930_DEFAULT_PGAIN), "Default pgain"); 199 CHECK_LOGE(dev, apds9930_setProximityGain(dev, APDS9930_DEFAULT_PGAIN), "Default pgain");
200 CHECK_LOGE(dev, apds9930_setAmbientLightGain(dev, APDS9930_DEFAULT_AGAIN), "Default again"); 200 CHECK_LOGE(dev, apds9930_setAmbientLightGain(dev, APDS9930_DEFAULT_AGAIN), "Default again");
203 CHECK_LOGE(dev, apds9930_setProximityIntHighThreshold(dev, APDS9930_DEFAULT_PIHT), "Default PIHT"); 203 CHECK_LOGE(dev, apds9930_setProximityIntHighThreshold(dev, APDS9930_DEFAULT_PIHT), "Default PIHT");
204 CHECK_LOGE(dev, apds9930_setLightIntLowThreshold(dev, APDS9930_DEFAULT_AILT), "Default ailt"); 204 CHECK_LOGE(dev, apds9930_setLightIntLowThreshold(dev, APDS9930_DEFAULT_AILT), "Default ailt");
205 CHECK_LOGE(dev, apds9930_setLightIntHighThreshold(dev, APDS9930_DEFAULT_AIHT), "Default aiht"); 205 CHECK_LOGE(dev, apds9930_setLightIntHighThreshold(dev, APDS9930_DEFAULT_AIHT), "Default aiht");
206 206
207 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 207 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
208 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_PERS, APDS9930_DEFAULT_PERS), "Default pers"); 208 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_PERS | APDS9930_AUTO_INCREMENT, APDS9930_DEFAULT_PERS), "Default pers");
209 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 209 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
210 210
211 return err; 211 return err;
212 } 212 }
213 213
219 { 219 {
220 uint8_t enable_value; 220 uint8_t enable_value;
221 221
222 /* Read current ENABLE register */ 222 /* Read current ENABLE register */
223 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 223 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
224 if (read_reg_8_nolock(dev, APDS9930_ENABLE, &enable_value) != ESP_OK) { 224 if (read_reg_8_nolock(dev, APDS9930_ENABLE | APDS9930_AUTO_INCREMENT, &enable_value) != ESP_OK) {
225 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 225 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
226 return APDS9930_ERROR; 226 return APDS9930_ERROR;
227 } 227 }
228 228
229 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 229 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
236 uint8_t reg_val; 236 uint8_t reg_val;
237 237
238 // CHECK_ARG(dev); 238 // CHECK_ARG(dev);
239 /* Read current ENABLE register */ 239 /* Read current ENABLE register */
240 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 240 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
241 I2C_DEV_CHECK(&dev->i2c_dev, read_reg_8_nolock(dev, APDS9930_ENABLE, &reg_val)); 241 I2C_DEV_CHECK(&dev->i2c_dev, read_reg_8_nolock(dev, APDS9930_ENABLE | APDS9930_AUTO_INCREMENT, &reg_val));
242 // i2c_dev_read_reg(&dev->i2c_dev, (uint8_t)APDS9930_ENABLE, &reg_val, 1); 242 // i2c_dev_read_reg(&dev->i2c_dev, (uint8_t)APDS9930_ENABLE, &reg_val, 1);
243 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 243 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
244 ESP_LOGI(TAG, "apds9930_setMode(%d, %d) get=%02x", mode, enable, reg_val); 244 ESP_LOGI(TAG, "apds9930_setMode(%d, %d) get=%02x", mode, enable, reg_val);
245 245
246 /* Change bit(s) in ENABLE register */ 246 /* Change bit(s) in ENABLE register */
260 } 260 }
261 261
262 ESP_LOGI(TAG, "apds9930_setMode write %02x", reg_val); 262 ESP_LOGI(TAG, "apds9930_setMode write %02x", reg_val);
263 /* Write value back to ENABLE register */ 263 /* Write value back to ENABLE register */
264 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 264 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
265 I2C_DEV_CHECK(&dev->i2c_dev, write_reg_8_nolock(dev, APDS9930_ENABLE, reg_val)); 265 I2C_DEV_CHECK(&dev->i2c_dev, write_reg_8_nolock(dev, APDS9930_ENABLE | APDS9930_AUTO_INCREMENT, reg_val));
266 // CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_ENABLE, reg_val), "Enable register"); 266 // CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_ENABLE, reg_val), "Enable register");
267 // CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, (uint8_t)APDS9930_ENABLE, &reg_val, 1), "Enable register"); 267 // CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, (uint8_t)APDS9930_ENABLE, &reg_val, 1), "Enable register");
268 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 268 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
269 269
270 //vTaskDelay(12 / portTICK_PERIOD_MS); 270 //vTaskDelay(12 / portTICK_PERIOD_MS);
416 416
417 CHECK_ARG(dev); 417 CHECK_ARG(dev);
418 418
419 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 419 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
420 /* Read value from channel 0 */ 420 /* Read value from channel 0 */
421 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, (uint8_t)APDS9930_Ch0DATAL, &val_byte, 1), "Read ch0 low"); 421 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, (uint8_t)APDS9930_Ch0DATAL | APDS9930_AUTO_INCREMENT, &val_byte, 1), "Read ch0 low");
422 ESP_LOGI(TAG, "l %02x", val_byte); 422 ESP_LOGI(TAG, "l %02x", val_byte);
423 *val = val_byte; 423 *val = val_byte;
424 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, (uint8_t)APDS9930_Ch0DATAH, &val_byte, 1), "Read ch0 high"); 424 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, (uint8_t)APDS9930_Ch0DATAH | APDS9930_AUTO_INCREMENT, &val_byte, 1), "Read ch0 high");
425 ESP_LOGI(TAG, "h %02x", val_byte); 425 ESP_LOGI(TAG, "h %02x", val_byte);
426 *val += ((uint16_t)val_byte << 8); 426 *val += ((uint16_t)val_byte << 8);
427 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 427 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
428 ESP_LOGI(TAG, "val %04x", *val); 428 ESP_LOGI(TAG, "val %04x", *val);
429 429
430 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, (uint8_t)APDS9930_Ch0DATAL, &val_word, 2), "Read ch0 16"); 430 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, (uint8_t)APDS9930_Ch0DATAL | APDS9930_AUTO_INCREMENT, &val_word, 2), "Read ch0 16");
431 ESP_LOGI(TAG, "16 %04x", val_word); 431 ESP_LOGI(TAG, "16 %04x", val_word);
432 432
433 return ESP_OK; 433 return ESP_OK;
434 } 434 }
435 435
439 uint8_t val_byte; 439 uint8_t val_byte;
440 *val = 0; 440 *val = 0;
441 441
442 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 442 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
443 /* Read value from channel 1 */ 443 /* Read value from channel 1 */
444 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_Ch1DATAL, &val_byte, 1), "Read ch1 low"); 444 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_Ch1DATAL | APDS9930_AUTO_INCREMENT, &val_byte, 1), "Read ch1 low");
445 *val = val_byte; 445 *val = val_byte;
446 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_Ch1DATAH, &val_byte, 1), "Read ch1 high"); 446 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_Ch1DATAH | APDS9930_AUTO_INCREMENT, &val_byte, 1), "Read ch1 high");
447 *val += ((uint16_t)val_byte << 8); 447 *val += ((uint16_t)val_byte << 8);
448 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 448 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
449 449
450 return ESP_OK; 450 return ESP_OK;
451 } 451 }
459 *val = 0; 459 *val = 0;
460 uint8_t val_byte; 460 uint8_t val_byte;
461 461
462 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 462 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
463 /* Read value from proximity data register */ 463 /* Read value from proximity data register */
464 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PDATAL, &val_byte, 1), "Read proximity low"); 464 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PDATAL | APDS9930_AUTO_INCREMENT, &val_byte, 1), "Read proximity low");
465 *val = val_byte; 465 *val = val_byte;
466 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PDATAH, &val_byte, 1), "Read proximity high"); 466 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PDATAH | APDS9930_AUTO_INCREMENT, &val_byte, 1), "Read proximity high");
467 *val += ((uint16_t)val_byte << 8); 467 *val += ((uint16_t)val_byte << 8);
468 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 468 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
469 469
470 return ESP_OK; 470 return ESP_OK;
471 } 471 }
479 uint16_t val; 479 uint16_t val;
480 uint8_t val_byte; 480 uint8_t val_byte;
481 481
482 /* Read value from PILT register */ 482 /* Read value from PILT register */
483 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 483 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
484 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PILTL, &val_byte, 1) != ESP_OK) { 484 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PILTL | APDS9930_AUTO_INCREMENT, &val_byte, 1) != ESP_OK) {
485 val = 0; 485 val = 0;
486 } 486 }
487 val = val_byte; 487 val = val_byte;
488 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PILTH, &val_byte, 1) != ESP_OK) { 488 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PILTH | APDS9930_AUTO_INCREMENT, &val_byte, 1) != ESP_OK) {
489 val = 0; 489 val = 0;
490 } 490 }
491 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 491 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
492 val |= ((uint16_t)val_byte << 8); 492 val |= ((uint16_t)val_byte << 8);
493 493
501 uint8_t hi; 501 uint8_t hi;
502 hi = threshold >> 8; 502 hi = threshold >> 8;
503 lo = threshold & 0x00FF; 503 lo = threshold & 0x00FF;
504 504
505 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 505 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
506 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_PILTL, &lo, 1), "Write PILTL"); 506 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_PILTL | APDS9930_AUTO_INCREMENT, &lo, 1), "Write PILTL");
507 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_PILTH, &hi, 1), "Write PILTH"); 507 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_PILTH | APDS9930_AUTO_INCREMENT, &hi, 1), "Write PILTH");
508 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 508 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
509 509
510 return ESP_OK; 510 return ESP_OK;
511 } 511 }
512 512
516 uint16_t val; 516 uint16_t val;
517 uint8_t val_byte; 517 uint8_t val_byte;
518 518
519 /* Read value from PIHT register */ 519 /* Read value from PIHT register */
520 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 520 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
521 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PIHTL, &val_byte, 1) != ESP_OK) { 521 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PIHTL | APDS9930_AUTO_INCREMENT, &val_byte, 1) != ESP_OK) {
522 val = 0; 522 val = 0;
523 } 523 }
524 val = val_byte; 524 val = val_byte;
525 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PIHTH, &val_byte, 1) != ESP_OK) { 525 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PIHTH | APDS9930_AUTO_INCREMENT, &val_byte, 1) != ESP_OK) {
526 val = 0; 526 val = 0;
527 } 527 }
528 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 528 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
529 val |= ((uint16_t)val_byte << 8); 529 val |= ((uint16_t)val_byte << 8);
530 530
538 uint8_t hi; 538 uint8_t hi;
539 hi = threshold >> 8; 539 hi = threshold >> 8;
540 lo = threshold & 0x00FF; 540 lo = threshold & 0x00FF;
541 541
542 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 542 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
543 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_PIHTL, &lo, 1), "Write PIHTL"); 543 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_PIHTL | APDS9930_AUTO_INCREMENT, &lo, 1), "Write PIHTL");
544 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_PIHTH, &hi, 1), "Write PIHTH"); 544 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_PIHTH | APDS9930_AUTO_INCREMENT, &hi, 1), "Write PIHTH");
545 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 545 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
546 546
547 return ESP_OK; 547 return ESP_OK;
548 } 548 }
549 549
552 { 552 {
553 uint8_t val; 553 uint8_t val;
554 554
555 /* Read value from CONTROL register */ 555 /* Read value from CONTROL register */
556 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 556 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
557 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1) != ESP_OK) { 557 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL | APDS9930_AUTO_INCREMENT, &val, 1) != ESP_OK) {
558 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 558 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
559 return APDS9930_ERROR;; 559 return APDS9930_ERROR;;
560 } 560 }
561 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 561 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
562 562
571 { 571 {
572 uint8_t val; 572 uint8_t val;
573 573
574 /* Read value from CONTROL register */ 574 /* Read value from CONTROL register */
575 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 575 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
576 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Read control"); 576 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL | APDS9930_AUTO_INCREMENT, &val, 1), "Read control");
577 577
578 /* Set bits in register to given value */ 578 /* Set bits in register to given value */
579 drive &= 0b00000011; 579 drive &= 0b00000011;
580 drive = drive << 6; 580 drive = drive << 6;
581 val &= 0b00111111; 581 val &= 0b00111111;
582 val |= drive; 582 val |= drive;
583 583
584 /* Write register value back into CONTROL register */ 584 /* Write register value back into CONTROL register */
585 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Write control"); 585 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_CONTROL | APDS9930_AUTO_INCREMENT, &val, 1), "Write control");
586 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 586 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
587 587
588 return ESP_OK; 588 return ESP_OK;
589 } 589 }
590 590
593 { 593 {
594 uint8_t val; 594 uint8_t val;
595 595
596 /* Read value from CONTROL register */ 596 /* Read value from CONTROL register */
597 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 597 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
598 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1) != ESP_OK) { 598 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL | APDS9930_AUTO_INCREMENT, &val, 1) != ESP_OK) {
599 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 599 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
600 return APDS9930_ERROR;; 600 return APDS9930_ERROR;;
601 } 601 }
602 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 602 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
603 603
612 { 612 {
613 uint8_t val; 613 uint8_t val;
614 614
615 /* Read value from CONTROL register */ 615 /* Read value from CONTROL register */
616 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 616 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
617 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Read control"); 617 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL | APDS9930_AUTO_INCREMENT, &val, 1), "Read control");
618 618
619 /* Set bits in register to given value */ 619 /* Set bits in register to given value */
620 drive &= 0b00000011; 620 drive &= 0b00000011;
621 drive = drive << 2; 621 drive = drive << 2;
622 val &= 0b11110011; 622 val &= 0b11110011;
623 val |= drive; 623 val |= drive;
624 624
625 /* Write register value back into CONTROL register */ 625 /* Write register value back into CONTROL register */
626 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Write control"); 626 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_CONTROL | APDS9930_AUTO_INCREMENT, &val, 1), "Write control");
627 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 627 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
628 628
629 return ESP_OK; 629 return ESP_OK;
630 } 630 }
631 631
634 { 634 {
635 uint8_t val; 635 uint8_t val;
636 636
637 /* Read value from CONTROL register */ 637 /* Read value from CONTROL register */
638 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 638 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
639 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1) != ESP_OK) { 639 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL | APDS9930_AUTO_INCREMENT, &val, 1) != ESP_OK) {
640 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 640 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
641 return APDS9930_ERROR;; 641 return APDS9930_ERROR;;
642 } 642 }
643 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 643 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
644 644
653 { 653 {
654 uint8_t val; 654 uint8_t val;
655 655
656 /* Read value from CONTROL register */ 656 /* Read value from CONTROL register */
657 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 657 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
658 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Read control"); 658 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL | APDS9930_AUTO_INCREMENT, &val, 1), "Read control");
659 659
660 /* Set bits in register to given value */ 660 /* Set bits in register to given value */
661 drive &= 0b00000011; 661 drive &= 0b00000011;
662 drive = drive << 4; 662 drive = drive << 4;
663 val &= 0b11001111; 663 val &= 0b11001111;
664 val |= drive; 664 val |= drive;
665 665
666 /* Write register value back into CONTROL register */ 666 /* Write register value back into CONTROL register */
667 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Write control"); 667 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_CONTROL | APDS9930_AUTO_INCREMENT, &val, 1), "Write control");
668 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 668 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
669 669
670 return ESP_OK; 670 return ESP_OK;
671 } 671 }
672 672
675 { 675 {
676 uint8_t val; 676 uint8_t val;
677 677
678 /* Read value from CONTROL register */ 678 /* Read value from CONTROL register */
679 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 679 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
680 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1) != ESP_OK) { 680 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL | APDS9930_AUTO_INCREMENT, &val, 1) != ESP_OK) {
681 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 681 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
682 return APDS9930_ERROR;; 682 return APDS9930_ERROR;;
683 } 683 }
684 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 684 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
685 685
694 { 694 {
695 uint8_t val; 695 uint8_t val;
696 696
697 /* Read value from CONTROL register */ 697 /* Read value from CONTROL register */
698 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 698 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
699 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Read control"); 699 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL | APDS9930_AUTO_INCREMENT, &val, 1), "Read control");
700 700
701 /* Set bits in register to given value */ 701 /* Set bits in register to given value */
702 drive &= 0b00000011; 702 drive &= 0b00000011;
703 val &= 0b11111100; 703 val &= 0b11111100;
704 val |= drive; 704 val |= drive;
705 705
706 /* Write register value back into CONTROL register */ 706 /* Write register value back into CONTROL register */
707 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Write control"); 707 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_CONTROL | APDS9930_AUTO_INCREMENT, &val, 1), "Write control");
708 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 708 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
709 709
710 return ESP_OK; 710 return ESP_OK;
711 } 711 }
712 712
715 { 715 {
716 uint8_t val; 716 uint8_t val;
717 717
718 /* Read value from CONTROL register */ 718 /* Read value from CONTROL register */
719 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 719 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
720 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1) != ESP_OK) { 720 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL | APDS9930_AUTO_INCREMENT, &val, 1) != ESP_OK) {
721 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 721 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
722 return APDS9930_ERROR;; 722 return APDS9930_ERROR;;
723 } 723 }
724 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 724 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
725 725
734 { 734 {
735 uint8_t val; 735 uint8_t val;
736 736
737 /* Read value from CONTROL register */ 737 /* Read value from CONTROL register */
738 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 738 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
739 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Read control"); 739 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL | APDS9930_AUTO_INCREMENT, &val, 1), "Read control");
740 740
741 /* Set bits in register to given value */ 741 /* Set bits in register to given value */
742 enable &= 0b00000001; 742 enable &= 0b00000001;
743 enable = enable << 2; 743 enable = enable << 2;
744 val &= 0b11111011; 744 val &= 0b11111011;
745 val |= enable; 745 val |= enable;
746 746
747 /* Write register value back into CONTROL register */ 747 /* Write register value back into CONTROL register */
748 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Write control"); 748 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_CONTROL | APDS9930_AUTO_INCREMENT, &val, 1), "Write control");
749 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 749 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
750 750
751 return ESP_OK; 751 return ESP_OK;
752 } 752 }
753 753
757 uint8_t val_byte; 757 uint8_t val_byte;
758 *threshold = 0; 758 *threshold = 0;
759 759
760 /* Read value from ambient light low threshold, low byte register */ 760 /* Read value from ambient light low threshold, low byte register */
761 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 761 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
762 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_AILTL, &val_byte, 1) != ESP_OK) { 762 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_AILTL | APDS9930_AUTO_INCREMENT, &val_byte, 1) != ESP_OK) {
763 *threshold = 0; 763 *threshold = 0;
764 } 764 }
765 *threshold = val_byte; 765 *threshold = val_byte;
766 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_AILTH, &val_byte, 1) != ESP_OK) { 766 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_AILTH | APDS9930_AUTO_INCREMENT, &val_byte, 1) != ESP_OK) {
767 *threshold = 0; 767 *threshold = 0;
768 } 768 }
769 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 769 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
770 *threshold = *threshold + ((uint16_t)val_byte << 8); 770 *threshold = *threshold + ((uint16_t)val_byte << 8);
771 771
781 /* Break 16-bit threshold into 2 8-bit values */ 781 /* Break 16-bit threshold into 2 8-bit values */
782 val_low = threshold & 0x00FF; 782 val_low = threshold & 0x00FF;
783 val_high = (threshold & 0xFF00) >> 8; 783 val_high = (threshold & 0xFF00) >> 8;
784 784
785 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 785 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
786 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_AILTL, &val_low, 1), "Write AILTL"); 786 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_AILTL | APDS9930_AUTO_INCREMENT, &val_low, 1), "Write AILTL");
787 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_AILTH, &val_high, 1), "Write AILTH"); 787 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_AILTH | APDS9930_AUTO_INCREMENT, &val_high, 1), "Write AILTH");
788 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 788 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
789 789
790 return ESP_OK; 790 return ESP_OK;
791 } 791 }
792 792
796 uint8_t val_byte; 796 uint8_t val_byte;
797 *threshold = 0; 797 *threshold = 0;
798 798
799 /* Read value from ambient light high threshold, low byte register */ 799 /* Read value from ambient light high threshold, low byte register */
800 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 800 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
801 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_AIHTL, &val_byte, 1) != ESP_OK) { 801 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_AIHTL | APDS9930_AUTO_INCREMENT, &val_byte, 1) != ESP_OK) {
802 *threshold = 0; 802 *threshold = 0;
803 } 803 }
804 *threshold = val_byte; 804 *threshold = val_byte;
805 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_AIHTH, &val_byte, 1) != ESP_OK) { 805 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_AIHTH | APDS9930_AUTO_INCREMENT, &val_byte, 1) != ESP_OK) {
806 *threshold = 0; 806 *threshold = 0;
807 } 807 }
808 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 808 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
809 *threshold = *threshold + ((uint16_t)val_byte << 8); 809 *threshold = *threshold + ((uint16_t)val_byte << 8);
810 810
820 /* Break 16-bit threshold into 2 8-bit values */ 820 /* Break 16-bit threshold into 2 8-bit values */
821 val_low = threshold & 0x00FF; 821 val_low = threshold & 0x00FF;
822 val_high = (threshold & 0xFF00) >> 8; 822 val_high = (threshold & 0xFF00) >> 8;
823 823
824 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 824 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
825 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_AIHTL, &val_low, 1), "Write AIHTL"); 825 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_AIHTL | APDS9930_AUTO_INCREMENT, &val_low, 1), "Write AIHTL");
826 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_AIHTH, &val_high, 1), "Write AIHTH"); 826 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_AIHTH | APDS9930_AUTO_INCREMENT, &val_high, 1), "Write AIHTH");
827 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 827 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
828 828
829 return ESP_OK; 829 return ESP_OK;
830 } 830 }
831 831
834 { 834 {
835 uint8_t val; 835 uint8_t val;
836 836
837 /* Read value from ENABLE register */ 837 /* Read value from ENABLE register */
838 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 838 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
839 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_ENABLE, &val, 1) != ESP_OK) { 839 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_ENABLE | APDS9930_AUTO_INCREMENT, &val, 1) != ESP_OK) {
840 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 840 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
841 return APDS9930_ERROR;; 841 return APDS9930_ERROR;;
842 } 842 }
843 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 843 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
844 844
853 { 853 {
854 uint8_t val; 854 uint8_t val;
855 855
856 /* Read value from ENABLE register */ 856 /* Read value from ENABLE register */
857 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 857 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
858 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_ENABLE, &val, 1), "Read enable"); 858 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_ENABLE | APDS9930_AUTO_INCREMENT, &val, 1), "Read enable");
859 859
860 /* Set bits in register to given value */ 860 /* Set bits in register to given value */
861 enable &= 0b00000001; 861 enable &= 0b00000001;
862 enable = enable << 4; 862 enable = enable << 4;
863 val &= 0b11101111; 863 val &= 0b11101111;
864 val |= enable; 864 val |= enable;
865 865
866 /* Write register value back into ENABLE register */ 866 /* Write register value back into ENABLE register */
867 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_ENABLE, &val, 1), "Write enable"); 867 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_ENABLE | APDS9930_AUTO_INCREMENT, &val, 1), "Write enable");
868 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 868 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
869 869
870 return ESP_OK; 870 return ESP_OK;
871 } 871 }
872 872
875 { 875 {
876 uint8_t val; 876 uint8_t val;
877 877
878 /* Read value from ENABLE register */ 878 /* Read value from ENABLE register */
879 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 879 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
880 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_ENABLE, &val, 1) != ESP_OK) { 880 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_ENABLE | APDS9930_AUTO_INCREMENT, &val, 1) != ESP_OK) {
881 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 881 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
882 return APDS9930_ERROR;; 882 return APDS9930_ERROR;;
883 } 883 }
884 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 884 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
885 885
894 { 894 {
895 uint8_t val; 895 uint8_t val;
896 896
897 /* Read value from ENABLE register */ 897 /* Read value from ENABLE register */
898 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev); 898 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
899 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_ENABLE, &val, 1), "Read enable"); 899 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_ENABLE | APDS9930_AUTO_INCREMENT, &val, 1), "Read enable");
900 900
901 /* Set bits in register to given value */ 901 /* Set bits in register to given value */
902 enable &= 0b00000001; 902 enable &= 0b00000001;
903 enable = enable << 5; 903 enable = enable << 5;
904 val &= 0b11011111; 904 val &= 0b11011111;
905 val |= enable; 905 val |= enable;
906 906
907 /* Write register value back into ENABLE register */ 907 /* Write register value back into ENABLE register */
908 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_ENABLE, &val, 1), "Write enable"); 908 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_ENABLE | APDS9930_AUTO_INCREMENT, &val, 1), "Write enable");
909 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); 909 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
910 910
911 return ESP_OK; 911 return ESP_OK;
912 } 912 }
913 913

Mercurial Repository: iotbalkon

mercurial