Mercurial > iotbalkon / file comparison

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

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

changeset 12
bb72d448e282
parent 11
bdc123ae7b49
child 16
b3e96bbe4ce4
equal deleted inserted replaced
11:bdc123ae7b49 12:bb72d448e282
115 #define CHECK(x) do { esp_err_t __; if ((__ = x) != ESP_OK) return __; } while (0) 115 #define CHECK(x) do { esp_err_t __; if ((__ = x) != ESP_OK) return __; } while (0)
116 #define CHECK_ARG(VAL) do { if (!(VAL)) return ESP_ERR_INVALID_ARG; } while (0) 116 #define CHECK_ARG(VAL) do { if (!(VAL)) return ESP_ERR_INVALID_ARG; } while (0)
117 #define CHECK_LOGE(dev, x, msg, ...) do { \ 117 #define CHECK_LOGE(dev, x, msg, ...) do { \
118 esp_err_t __; \ 118 esp_err_t __; \
119 if ((__ = x) != ESP_OK) { \ 119 if ((__ = x) != ESP_OK) { \
120 I2C_DEV_GIVE_MUTEX(dev); \ 120 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev); \
121 ESP_LOGE(TAG, msg, ## __VA_ARGS__); \ 121 ESP_LOGE(TAG, msg, ## __VA_ARGS__); \
122 return __; \ 122 return __; \
123 } \ 123 } \
124 } while (0) 124 } while (0)
125 125
128 { 128 {
129 return i2c_dev_write_reg(dev, addr, &value, 1); 129 return i2c_dev_write_reg(dev, addr, &value, 1);
130 } 130 }
131 131
132 132
133 esp_err_t apds9930_init_desc(i2c_dev_t *dev, uint8_t addr, i2c_port_t port, gpio_num_t sda_gpio, gpio_num_t scl_gpio) 133 esp_err_t apds9930_init_desc(apds9930_t *dev, uint8_t addr, i2c_port_t port, gpio_num_t sda_gpio, gpio_num_t scl_gpio)
134 { 134 {
135 CHECK_ARG(dev); 135 CHECK_ARG(dev);
136 CHECK_ARG(addr & 0x20); 136
137 137 if (addr != 0x39) {
138 dev->port = port; 138 ESP_LOGE(TAG, "Invalid I2C address");
139 dev->addr = addr; 139 return ESP_ERR_INVALID_ARG;
140 dev->cfg.sda_io_num = sda_gpio; 140 }
141 dev->cfg.scl_io_num = scl_gpio; 141
142 dev->i2c_dev.port = port;
143 dev->i2c_dev.addr = addr;
144 dev->i2c_dev.cfg.sda_io_num = sda_gpio;
145 dev->i2c_dev.cfg.scl_io_num = scl_gpio;
142 #if HELPER_TARGET_IS_ESP32 146 #if HELPER_TARGET_IS_ESP32
143 dev->cfg.master.clk_speed = I2C_FREQ_HZ; 147 dev->i2c_dev.cfg.master.clk_speed = I2C_FREQ_HZ;
144 #endif 148 #endif
145 149
146 return i2c_dev_create_mutex(dev); 150 return i2c_dev_create_mutex(&dev->i2c_dev);
147 } 151 }
148 152
149 153
150 esp_err_t apds9930_free_desc(i2c_dev_t *dev) 154 esp_err_t apds9930_free_desc(apds9930_t *dev)
151 { 155 {
152 CHECK_ARG(dev); 156 CHECK_ARG(dev);
153 157
154 return i2c_dev_delete_mutex(dev); 158 return i2c_dev_delete_mutex(&dev->i2c_dev);
155 } 159 }
156 160
157 161
158 esp_err_t apds9930_init(i2c_dev_t *dev) 162 esp_err_t apds9930_init(apds9930_t *dev)
159 { 163 {
160 esp_err_t err = ESP_OK; 164 esp_err_t err = ESP_OK;
161 uint8_t id;
162 165
163 CHECK_ARG(dev); 166 CHECK_ARG(dev);
164 I2C_DEV_TAKE_MUTEX(dev); 167 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
165 168
166 CHECK_LOGE(dev, i2c_dev_read_reg(dev, APDS9930_ID, &id, 1), "Sensor not found"); 169 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_ID, &dev->id, 1), "Sensor not found");
167 170
168 if (id != APDS9930_ID_1 && id != APDS9930_ID_2 && id != APDS9930_ID_3) { 171 if (dev->id != APDS9930_ID_1 && dev->id != APDS9930_ID_2 && dev->id != APDS9930_ID_3) {
169 CHECK_LOGE(dev, ESP_ERR_INVALID_VERSION, 172 CHECK_LOGE(dev, ESP_ERR_INVALID_VERSION,
170 "Invalid chip ID: expected: 0x%x or 0x%x or 0x%x got: 0x%x", 173 "Invalid chip ID: expected: 0x%x or 0x%x or 0x%x got: 0x%x",
171 APDS9930_ID_1, APDS9930_ID_2, APDS9930_ID_3, id); 174 APDS9930_ID_1, APDS9930_ID_2, APDS9930_ID_3, dev->id);
172 } 175 }
173 176
174 /* Set ENABLE register to 0 (disable all features) */ 177 /* Set ENABLE register to 0 (disable all features) */
175 if ( !apds9930_setMode(dev, APDS9930_MODE_ALL, APDS9930_OFF) ) { 178 if ( !apds9930_setMode(dev, APDS9930_MODE_ALL, APDS9930_OFF) ) {
176 ESP_LOGE(TAG, "Regs off"); 179 ESP_LOGE(TAG, "Regs off");
177 err = ESP_ERR_INVALID_ARG; 180 err = ESP_ERR_INVALID_ARG;
178 } 181 }
179 182
180 /* Set default values for ambient light and proximity registers */ 183 /* Set default values for ambient light and proximity registers */
181 CHECK_LOGE(dev, write_register8(dev, APDS9930_ATIME, APDS9930_DEFAULT_ATIME), "Default atime"); 184 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_ATIME, APDS9930_DEFAULT_ATIME), "Default atime");
182 CHECK_LOGE(dev, write_register8(dev, APDS9930_WTIME, APDS9930_DEFAULT_WTIME), "Default wtime"); 185 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_WTIME, APDS9930_DEFAULT_WTIME), "Default wtime");
183 CHECK_LOGE(dev, write_register8(dev, APDS9930_PPULSE, APDS9930_DEFAULT_PPULSE), "Default ppulse"); 186 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_PPULSE, APDS9930_DEFAULT_PPULSE), "Default ppulse");
184 CHECK_LOGE(dev, write_register8(dev, APDS9930_POFFSET, APDS9930_DEFAULT_POFFSET), "Default poffset"); 187 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_POFFSET, APDS9930_DEFAULT_POFFSET), "Default poffset");
185 CHECK_LOGE(dev, write_register8(dev, APDS9930_CONFIG, APDS9930_DEFAULT_CONFIG), "Default config"); 188 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_CONFIG, APDS9930_DEFAULT_CONFIG), "Default config");
186 CHECK_LOGE(dev, apds9930_setLEDDrive(dev, APDS9930_DEFAULT_PDRIVE), "Default pdrive"); 189 CHECK_LOGE(dev, apds9930_setLEDDrive(dev, APDS9930_DEFAULT_PDRIVE), "Default pdrive");
187 CHECK_LOGE(dev, apds9930_setProximityGain(dev, APDS9930_DEFAULT_PGAIN), "Default pgain"); 190 CHECK_LOGE(dev, apds9930_setProximityGain(dev, APDS9930_DEFAULT_PGAIN), "Default pgain");
188 CHECK_LOGE(dev, apds9930_setAmbientLightGain(dev, APDS9930_DEFAULT_AGAIN), "Default again"); 191 CHECK_LOGE(dev, apds9930_setAmbientLightGain(dev, APDS9930_DEFAULT_AGAIN), "Default again");
189 CHECK_LOGE(dev, apds9930_setProximityDiode(dev, APDS9930_DEFAULT_PDIODE), "Default pdiode"); 192 CHECK_LOGE(dev, apds9930_setProximityDiode(dev, APDS9930_DEFAULT_PDIODE), "Default pdiode");
190 CHECK_LOGE(dev, apds9930_setProximityIntLowThreshold(dev, APDS9930_DEFAULT_PILT), "Default PILT"); 193 CHECK_LOGE(dev, apds9930_setProximityIntLowThreshold(dev, APDS9930_DEFAULT_PILT), "Default PILT");
191 CHECK_LOGE(dev, apds9930_setProximityIntHighThreshold(dev, APDS9930_DEFAULT_PIHT), "Default PIHT"); 194 CHECK_LOGE(dev, apds9930_setProximityIntHighThreshold(dev, APDS9930_DEFAULT_PIHT), "Default PIHT");
192 CHECK_LOGE(dev, apds9930_setLightIntLowThreshold(dev, APDS9930_DEFAULT_AILT), "Default ailt"); 195 CHECK_LOGE(dev, apds9930_setLightIntLowThreshold(dev, APDS9930_DEFAULT_AILT), "Default ailt");
193 CHECK_LOGE(dev, apds9930_setLightIntHighThreshold(dev, APDS9930_DEFAULT_AIHT), "Default aiht"); 196 CHECK_LOGE(dev, apds9930_setLightIntHighThreshold(dev, APDS9930_DEFAULT_AIHT), "Default aiht");
194 CHECK_LOGE(dev, write_register8(dev, APDS9930_PERS, APDS9930_DEFAULT_PERS), "Default pers"); 197 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_PERS, APDS9930_DEFAULT_PERS), "Default pers");
195 198
196 I2C_DEV_GIVE_MUTEX(dev); 199 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
197 return err; 200 return err;
198 } 201 }
199 202
200 /******************************************************************************* 203 /*******************************************************************************
201 * Public methods for controlling the APDS-9930 204 * Public methods for controlling the APDS-9930
202 ******************************************************************************/ 205 ******************************************************************************/
203 206
204 uint8_t apds9930_getMode(i2c_dev_t *dev) 207 uint8_t apds9930_getMode(apds9930_t *dev)
205 { 208 {
206 uint8_t enable_value; 209 uint8_t enable_value;
207 210
208 I2C_DEV_TAKE_MUTEX(dev); 211 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
209 /* Read current ENABLE register */ 212 /* Read current ENABLE register */
210 if (i2c_dev_read_reg(dev, APDS9930_ENABLE, &enable_value, 1) != ESP_OK) { 213 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_ENABLE, &enable_value, 1) != ESP_OK) {
211 I2C_DEV_GIVE_MUTEX(dev); 214 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
212 return APDS9930_ERROR; 215 return APDS9930_ERROR;
213 } 216 }
214 217
215 I2C_DEV_GIVE_MUTEX(dev); 218 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
216 return enable_value; 219 return enable_value;
217 } 220 }
218 221
219 222
220 esp_err_t apds9930_setMode(i2c_dev_t *dev, uint8_t mode, uint8_t enable) 223 esp_err_t apds9930_setMode(apds9930_t *dev, uint8_t mode, uint8_t enable)
221 { 224 {
222 uint8_t reg_val; 225 uint8_t reg_val;
223 226
224 CHECK_ARG(dev); 227 CHECK_ARG(dev);
225 /* Read current ENABLE register */ 228 /* Read current ENABLE register */
243 reg_val = 0x00; 246 reg_val = 0x00;
244 } 247 }
245 } 248 }
246 249
247 /* Write value back to ENABLE register */ 250 /* Write value back to ENABLE register */
248 I2C_DEV_TAKE_MUTEX(dev); 251 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
249 CHECK_LOGE(dev, write_register8(dev, APDS9930_ENABLE, reg_val), "Enable register"); 252 CHECK_LOGE(dev, write_register8(&dev->i2c_dev, APDS9930_ENABLE, reg_val), "Enable register");
250 I2C_DEV_GIVE_MUTEX(dev); 253 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
251 254
252 return ESP_OK; 255 return ESP_OK;
253 } 256 }
254 257
255 258
256 esp_err_t apds9930_enableLightSensor(i2c_dev_t *dev, bool interrupts) 259 esp_err_t apds9930_enableLightSensor(apds9930_t *dev, bool interrupts)
257 { 260 {
258 CHECK_ARG(dev); 261 CHECK_ARG(dev);
259 262
260 /* Set default gain, interrupts, enable power, and enable sensor */ 263 /* Set default gain, interrupts, enable power, and enable sensor */
261 CHECK_LOGE(dev, apds9930_setAmbientLightGain(dev, APDS9930_DEFAULT_AGAIN), "setAmbientLightGain"); 264 CHECK_LOGE(dev, apds9930_setAmbientLightGain(dev, APDS9930_DEFAULT_AGAIN), "setAmbientLightGain");
269 272
270 return ESP_OK; 273 return ESP_OK;
271 } 274 }
272 275
273 276
274 esp_err_t apds9930_disableLightSensor(i2c_dev_t *dev) 277 esp_err_t apds9930_disableLightSensor(apds9930_t *dev)
275 { 278 {
276 CHECK_ARG(dev); 279 CHECK_ARG(dev);
277 280
278 CHECK_LOGE(dev, apds9930_setAmbientLightIntEnable(dev, 0), "setAmbientLightIntEnable(0)"); 281 CHECK_LOGE(dev, apds9930_setAmbientLightIntEnable(dev, 0), "setAmbientLightIntEnable(0)");
279 CHECK_LOGE(dev, apds9930_setMode(dev, APDS9930_MODE_AMBIENT_LIGHT, 0), "setMode"); 282 CHECK_LOGE(dev, apds9930_setMode(dev, APDS9930_MODE_AMBIENT_LIGHT, 0), "setMode");
280 283
281 return ESP_OK; 284 return ESP_OK;
282 } 285 }
283 286
284 287
285 esp_err_t apds9930_enableProximitySensor(i2c_dev_t *dev, bool interrupts) 288 esp_err_t apds9930_enableProximitySensor(apds9930_t *dev, bool interrupts)
286 { 289 {
287 CHECK_ARG(dev); 290 CHECK_ARG(dev);
288 291
289 /* Set default gain, LED, interrupts, enable power, and enable sensor */ 292 /* Set default gain, LED, interrupts, enable power, and enable sensor */
290 CHECK_LOGE(dev, apds9930_setProximityGain(dev, APDS9930_DEFAULT_PGAIN), "setProximityGain"); 293 CHECK_LOGE(dev, apds9930_setProximityGain(dev, APDS9930_DEFAULT_PGAIN), "setProximityGain");
299 302
300 return ESP_OK; 303 return ESP_OK;
301 } 304 }
302 305
303 306
304 esp_err_t apds9930_disableProximitySensor(i2c_dev_t *dev) 307 esp_err_t apds9930_disableProximitySensor(apds9930_t *dev)
305 { 308 {
306 CHECK_ARG(dev); 309 CHECK_ARG(dev);
307 310
308 CHECK_LOGE(dev, apds9930_setProximityIntEnable(dev, 0), "setProximityIntEnable(0)"); 311 CHECK_LOGE(dev, apds9930_setProximityIntEnable(dev, 0), "setProximityIntEnable(0)");
309 CHECK_LOGE(dev, apds9930_setMode(dev, APDS9930_MODE_PROXIMITY, 0), "setMode"); 312 CHECK_LOGE(dev, apds9930_setMode(dev, APDS9930_MODE_PROXIMITY, 0), "setMode");
310 313
311 return ESP_OK; 314 return ESP_OK;
312 } 315 }
313 316
314 317
315 esp_err_t apds9930_enablePower(i2c_dev_t *dev) 318 esp_err_t apds9930_enablePower(apds9930_t *dev)
316 { 319 {
317 return apds9930_setMode(dev, APDS9930_MODE_POWER, 1); 320 return apds9930_setMode(dev, APDS9930_MODE_POWER, 1);
318 } 321 }
319 322
320 323
321 esp_err_t apds9930_disablePower(i2c_dev_t *dev) 324 esp_err_t apds9930_disablePower(apds9930_t *dev)
322 { 325 {
323 return apds9930_setMode(dev, APDS9930_MODE_POWER, 0); 326 return apds9930_setMode(dev, APDS9930_MODE_POWER, 0);
324 } 327 }
325 328
326 329
327 /******************************************************************************* 330 /*******************************************************************************
328 * Ambient light sensor controls 331 * Ambient light sensor controls
329 ******************************************************************************/ 332 ******************************************************************************/
330 333
331 esp_err_t apds9930_readAmbientLightLux(i2c_dev_t *dev, float *val) 334 esp_err_t apds9930_readAmbientLightLux(apds9930_t *dev, float *val)
332 { 335 {
333 uint16_t Ch0, Ch1; 336 uint16_t Ch0, Ch1;
334 337
335 /* Read value from channels */ 338 /* Read value from channels */
336 CHECK_LOGE(dev, apds9930_readCh0Light(dev, &Ch0), "read ch0"); 339 CHECK_LOGE(dev, apds9930_readCh0Light(dev, &Ch0), "read ch0");
339 342
340 return ESP_OK; 343 return ESP_OK;
341 } 344 }
342 345
343 346
344 esp_err_t apds9930_readulAmbientLightLux(i2c_dev_t *dev, unsigned long *val) 347 esp_err_t apds9930_readulAmbientLightLux(apds9930_t *dev, unsigned long *val)
345 { 348 {
346 uint16_t Ch0, Ch1; 349 uint16_t Ch0, Ch1;
347 350
348 /* Read value from channels */ 351 /* Read value from channels */
349 CHECK_LOGE(dev, apds9930_readCh0Light(dev, &Ch0), "read ch0"); 352 CHECK_LOGE(dev, apds9930_readCh0Light(dev, &Ch0), "read ch0");
352 355
353 return ESP_OK; 356 return ESP_OK;
354 } 357 }
355 358
356 359
357 float apds9930_floatAmbientToLux(i2c_dev_t *dev, uint16_t Ch0, uint16_t Ch1) 360 float apds9930_floatAmbientToLux(apds9930_t *dev, uint16_t Ch0, uint16_t Ch1)
358 { 361 {
359 uint8_t x[4] = {1,8,16,120}; 362 uint8_t x[4] = {1,8,16,120};
360 float iac; 363 float iac;
361 364
362 float ALSIT = 2.73 * (256 - APDS9930_DEFAULT_ATIME); 365 float ALSIT = 2.73 * (256 - APDS9930_DEFAULT_ATIME);
370 float lpc = APDS9930_GA * APDS9930_DF / (ALSIT * x[apds9930_getAmbientLightGain(dev)]); 373 float lpc = APDS9930_GA * APDS9930_DF / (ALSIT * x[apds9930_getAmbientLightGain(dev)]);
371 return iac * lpc; 374 return iac * lpc;
372 } 375 }
373 376
374 377
375 unsigned long apds9930_ulongAmbientToLux(i2c_dev_t *dev, uint16_t Ch0, uint16_t Ch1) 378 unsigned long apds9930_ulongAmbientToLux(apds9930_t *dev, uint16_t Ch0, uint16_t Ch1)
376 { 379 {
377 uint8_t x[4] = {1,8,16,120}; 380 uint8_t x[4] = {1,8,16,120};
378 unsigned long iac; 381 unsigned long iac;
379 382
380 unsigned long ALSIT = 2.73 * (256 - APDS9930_DEFAULT_ATIME); 383 unsigned long ALSIT = 2.73 * (256 - APDS9930_DEFAULT_ATIME);
387 unsigned long lpc = APDS9930_GA * APDS9930_DF / (ALSIT * x[apds9930_getAmbientLightGain(dev)]); 390 unsigned long lpc = APDS9930_GA * APDS9930_DF / (ALSIT * x[apds9930_getAmbientLightGain(dev)]);
388 return iac * lpc; 391 return iac * lpc;
389 } 392 }
390 393
391 394
392 esp_err_t apds9930_readCh0Light(i2c_dev_t *dev, uint16_t *val) 395 esp_err_t apds9930_readCh0Light(apds9930_t *dev, uint16_t *val)
393 { 396 {
394 uint8_t val_byte; 397 uint8_t val_byte;
395 *val = 0; 398 *val = 0;
396 399
397 CHECK_ARG(dev); 400 CHECK_ARG(dev);
398 401
399 I2C_DEV_TAKE_MUTEX(dev); 402 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
400 /* Read value from channel 0 */ 403 /* Read value from channel 0 */
401 CHECK_LOGE(dev, i2c_dev_read_reg(dev, APDS9930_Ch0DATAL, &val_byte, 1), "Read ch0 low"); 404 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_Ch0DATAL, &val_byte, 1), "Read ch0 low");
402 *val = val_byte; 405 *val = val_byte;
403 CHECK_LOGE(dev, i2c_dev_read_reg(dev, APDS9930_Ch0DATAH, &val_byte, 1), "Read ch0 high"); 406 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_Ch0DATAH, &val_byte, 1), "Read ch0 high");
404 *val += ((uint16_t)val_byte << 8); 407 *val += ((uint16_t)val_byte << 8);
405 I2C_DEV_GIVE_MUTEX(dev); 408 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
406 409
407 return ESP_OK; 410 return ESP_OK;
408 } 411 }
409 412
410 413
411 esp_err_t apds9930_readCh1Light(i2c_dev_t *dev, uint16_t *val) 414 esp_err_t apds9930_readCh1Light(apds9930_t *dev, uint16_t *val)
412 { 415 {
413 uint8_t val_byte; 416 uint8_t val_byte;
414 *val = 0; 417 *val = 0;
415 418
416 I2C_DEV_TAKE_MUTEX(dev); 419 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
417 /* Read value from channel 1 */ 420 /* Read value from channel 1 */
418 CHECK_LOGE(dev, i2c_dev_read_reg(dev, APDS9930_Ch1DATAL, &val_byte, 1), "Read ch1 low"); 421 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_Ch1DATAL, &val_byte, 1), "Read ch1 low");
419 *val = val_byte; 422 *val = val_byte;
420 CHECK_LOGE(dev, i2c_dev_read_reg(dev, APDS9930_Ch1DATAH, &val_byte, 1), "Read ch1 high"); 423 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_Ch1DATAH, &val_byte, 1), "Read ch1 high");
421 *val += ((uint16_t)val_byte << 8); 424 *val += ((uint16_t)val_byte << 8);
422 I2C_DEV_GIVE_MUTEX(dev); 425 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
423 426
424 return ESP_OK; 427 return ESP_OK;
425 } 428 }
426 429
427 /******************************************************************************* 430 /*******************************************************************************
428 * Proximity sensor controls 431 * Proximity sensor controls
429 ******************************************************************************/ 432 ******************************************************************************/
430 433
431 esp_err_t apds9930_readProximity(i2c_dev_t *dev, uint16_t *val) 434 esp_err_t apds9930_readProximity(apds9930_t *dev, uint16_t *val)
432 { 435 {
433 *val = 0; 436 *val = 0;
434 uint8_t val_byte; 437 uint8_t val_byte;
435 438
436 I2C_DEV_TAKE_MUTEX(dev); 439 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
437 /* Read value from proximity data register */ 440 /* Read value from proximity data register */
438 CHECK_LOGE(dev, i2c_dev_read_reg(dev, APDS9930_PDATAL, &val_byte, 1), "Read proximity low"); 441 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PDATAL, &val_byte, 1), "Read proximity low");
439 *val = val_byte; 442 *val = val_byte;
440 CHECK_LOGE(dev, i2c_dev_read_reg(dev, APDS9930_PDATAH, &val_byte, 1), "Read proximity high"); 443 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PDATAH, &val_byte, 1), "Read proximity high");
441 *val += ((uint16_t)val_byte << 8); 444 *val += ((uint16_t)val_byte << 8);
442 I2C_DEV_GIVE_MUTEX(dev); 445 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
443 446
444 return ESP_OK; 447 return ESP_OK;
445 } 448 }
446 449
447 /******************************************************************************* 450 /*******************************************************************************
448 * Getters and setters for register values 451 * Getters and setters for register values
449 ******************************************************************************/ 452 ******************************************************************************/
450 453
451 uint16_t apds9930_getProximityIntLowThreshold(i2c_dev_t *dev) 454 uint16_t apds9930_getProximityIntLowThreshold(apds9930_t *dev)
452 { 455 {
453 uint16_t val; 456 uint16_t val;
454 uint8_t val_byte; 457 uint8_t val_byte;
455 458
456 /* Read value from PILT register */ 459 /* Read value from PILT register */
457 I2C_DEV_TAKE_MUTEX(dev); 460 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
458 if (i2c_dev_read_reg(dev, APDS9930_PILTL, &val_byte, 1) != ESP_OK) { 461 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PILTL, &val_byte, 1) != ESP_OK) {
459 val = 0; 462 val = 0;
460 } 463 }
461 val = val_byte; 464 val = val_byte;
462 if (i2c_dev_read_reg(dev, APDS9930_PILTH, &val_byte, 1) != ESP_OK) { 465 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PILTH, &val_byte, 1) != ESP_OK) {
463 val = 0; 466 val = 0;
464 } 467 }
465 I2C_DEV_GIVE_MUTEX(dev); 468 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
466 val |= ((uint16_t)val_byte << 8); 469 val |= ((uint16_t)val_byte << 8);
467 470
468 return val; 471 return val;
469 } 472 }
470 473
471 474
472 esp_err_t apdsi9930_setProximityIntLowThreshold(i2c_dev_t *dev, uint16_t threshold) 475 esp_err_t apds9930_setProximityIntLowThreshold(apds9930_t *dev, uint16_t threshold)
473 { 476 {
474 uint8_t lo; 477 uint8_t lo;
475 uint8_t hi; 478 uint8_t hi;
476 hi = threshold >> 8; 479 hi = threshold >> 8;
477 lo = threshold & 0x00FF; 480 lo = threshold & 0x00FF;
478 481
479 I2C_DEV_TAKE_MUTEX(dev); 482 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
480 CHECK_LOGE(dev, i2c_dev_write_reg(dev, APDS9930_PILTL, &lo, 1), "Write PILTL"); 483 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_PILTL, &lo, 1), "Write PILTL");
481 CHECK_LOGE(dev, i2c_dev_write_reg(dev, APDS9930_PILTH, &hi, 1), "Write PILTH"); 484 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_PILTH, &hi, 1), "Write PILTH");
482 I2C_DEV_GIVE_MUTEX(dev); 485 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
483 486
484 return ESP_OK; 487 return ESP_OK;
485 } 488 }
486 489
487 490
488 uint16_t apds9930_getProximityIntHighThreshold(i2c_dev_t *dev) 491 uint16_t apds9930_getProximityIntHighThreshold(apds9930_t *dev)
489 { 492 {
490 uint16_t val; 493 uint16_t val;
491 uint8_t val_byte; 494 uint8_t val_byte;
492 495
493 /* Read value from PIHT register */ 496 /* Read value from PIHT register */
494 I2C_DEV_TAKE_MUTEX(dev); 497 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
495 if (i2c_dev_read_reg(dev, APDS9930_PIHTL, &val_byte, 1) != ESP_OK) { 498 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PIHTL, &val_byte, 1) != ESP_OK) {
496 val = 0; 499 val = 0;
497 } 500 }
498 val = val_byte; 501 val = val_byte;
499 if (i2c_dev_read_reg(dev, APDS9930_PIHTH, &val_byte, 1) != ESP_OK) { 502 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_PIHTH, &val_byte, 1) != ESP_OK) {
500 val = 0; 503 val = 0;
501 } 504 }
502 I2C_DEV_GIVE_MUTEX(dev); 505 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
503 val |= ((uint16_t)val_byte << 8); 506 val |= ((uint16_t)val_byte << 8);
504 507
505 return val; 508 return val;
506 } 509 }
507 510
508 511
509 esp_err_t apds9930_setProximityIntHighThreshold(i2c_dev_t *dev, uint16_t threshold) 512 esp_err_t apds9930_setProximityIntHighThreshold(apds9930_t *dev, uint16_t threshold)
510 { 513 {
511 uint8_t lo; 514 uint8_t lo;
512 uint8_t hi; 515 uint8_t hi;
513 hi = threshold >> 8; 516 hi = threshold >> 8;
514 lo = threshold & 0x00FF; 517 lo = threshold & 0x00FF;
515 518
516 I2C_DEV_TAKE_MUTEX(dev); 519 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
517 CHECK_LOGE(dev, i2c_dev_write_reg(dev, APDS9930_PIHTL, &lo, 1), "Write PIHTL"); 520 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_PIHTL, &lo, 1), "Write PIHTL");
518 CHECK_LOGE(dev, i2c_dev_write_reg(dev, APDS9930_PIHTH, &hi, 1), "Write PIHTH"); 521 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_PIHTH, &hi, 1), "Write PIHTH");
519 I2C_DEV_GIVE_MUTEX(dev); 522 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
520 523
521 return ESP_OK; 524 return ESP_OK;
522 } 525 }
523 526
524 527
525 uint8_t apds9930_getLEDDrive(i2c_dev_t *dev) 528 uint8_t apds9930_getLEDDrive(apds9930_t *dev)
526 { 529 {
527 uint8_t val; 530 uint8_t val;
528 531
529 /* Read value from CONTROL register */ 532 /* Read value from CONTROL register */
530 I2C_DEV_TAKE_MUTEX(dev); 533 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
531 if (i2c_dev_read_reg(dev, APDS9930_CONTROL, &val, 1) != ESP_OK) { 534 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1) != ESP_OK) {
532 I2C_DEV_GIVE_MUTEX(dev); 535 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
533 return APDS9930_ERROR;; 536 return APDS9930_ERROR;;
534 } 537 }
535 I2C_DEV_GIVE_MUTEX(dev); 538 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
536 539
537 /* Shift and mask out LED drive bits */ 540 /* Shift and mask out LED drive bits */
538 val = (val >> 6) & 0b00000011; 541 val = (val >> 6) & 0b00000011;
539 542
540 return val; 543 return val;
541 } 544 }
542 545
543 546
544 esp_err_t apds9930_setLEDDrive(i2c_dev_t *dev, uint8_t drive) 547 esp_err_t apds9930_setLEDDrive(apds9930_t *dev, uint8_t drive)
545 { 548 {
546 uint8_t val; 549 uint8_t val;
547 550
548 /* Read value from CONTROL register */ 551 /* Read value from CONTROL register */
549 I2C_DEV_TAKE_MUTEX(dev); 552 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
550 CHECK_LOGE(dev, i2c_dev_read_reg(dev, APDS9930_CONTROL, &val, 1), "Read control"); 553 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Read control");
551 554
552 /* Set bits in register to given value */ 555 /* Set bits in register to given value */
553 drive &= 0b00000011; 556 drive &= 0b00000011;
554 drive = drive << 6; 557 drive = drive << 6;
555 val &= 0b00111111; 558 val &= 0b00111111;
556 val |= drive; 559 val |= drive;
557 560
558 /* Write register value back into CONTROL register */ 561 /* Write register value back into CONTROL register */
559 CHECK_LOGE(dev, i2c_dev_write_reg(dev, APDS9930_CONTROL, &val, 1), "Write control"); 562 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Write control");
560 I2C_DEV_GIVE_MUTEX(dev); 563 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
561 564
562 return ESP_OK; 565 return ESP_OK;
563 } 566 }
564 567
565 568
566 uint8_t apds9930_getProximityGain(i2c_dev_t *dev) 569 uint8_t apds9930_getProximityGain(apds9930_t *dev)
567 { 570 {
568 uint8_t val; 571 uint8_t val;
569 572
570 /* Read value from CONTROL register */ 573 /* Read value from CONTROL register */
571 I2C_DEV_TAKE_MUTEX(dev); 574 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
572 if (i2c_dev_read_reg(dev, APDS9930_CONTROL, &val, 1) != ESP_OK) { 575 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1) != ESP_OK) {
573 I2C_DEV_GIVE_MUTEX(dev); 576 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
574 return APDS9930_ERROR;; 577 return APDS9930_ERROR;;
575 } 578 }
576 I2C_DEV_GIVE_MUTEX(dev); 579 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
577 580
578 /* Shift and mask out PDRIVE bits */ 581 /* Shift and mask out PDRIVE bits */
579 val = (val >> 2) & 0b00000011; 582 val = (val >> 2) & 0b00000011;
580 583
581 return val; 584 return val;
582 } 585 }
583 586
584 587
585 esp_err_t apds9930_setProximityGain(i2c_dev_t *dev, uint8_t drive) 588 esp_err_t apds9930_setProximityGain(apds9930_t *dev, uint8_t drive)
586 { 589 {
587 uint8_t val; 590 uint8_t val;
588 591
589 /* Read value from CONTROL register */ 592 /* Read value from CONTROL register */
590 I2C_DEV_TAKE_MUTEX(dev); 593 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
591 CHECK_LOGE(dev, i2c_dev_read_reg(dev, APDS9930_CONTROL, &val, 1), "Read control"); 594 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Read control");
592 595
593 /* Set bits in register to given value */ 596 /* Set bits in register to given value */
594 drive &= 0b00000011; 597 drive &= 0b00000011;
595 drive = drive << 2; 598 drive = drive << 2;
596 val &= 0b11110011; 599 val &= 0b11110011;
597 val |= drive; 600 val |= drive;
598 601
599 /* Write register value back into CONTROL register */ 602 /* Write register value back into CONTROL register */
600 CHECK_LOGE(dev, i2c_dev_write_reg(dev, APDS9930_CONTROL, &val, 1), "Write control"); 603 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Write control");
601 I2C_DEV_GIVE_MUTEX(dev); 604 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
602 605
603 return ESP_OK; 606 return ESP_OK;
604 } 607 }
605 608
606 609
607 uint8_t apds9930_getProximityDiode(i2c_dev_t *dev) 610 uint8_t apds9930_getProximityDiode(apds9930_t *dev)
608 { 611 {
609 uint8_t val; 612 uint8_t val;
610 613
611 /* Read value from CONTROL register */ 614 /* Read value from CONTROL register */
612 I2C_DEV_TAKE_MUTEX(dev); 615 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
613 if (i2c_dev_read_reg(dev, APDS9930_CONTROL, &val, 1) != ESP_OK) { 616 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1) != ESP_OK) {
614 I2C_DEV_GIVE_MUTEX(dev); 617 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
615 return APDS9930_ERROR;; 618 return APDS9930_ERROR;;
616 } 619 }
617 I2C_DEV_GIVE_MUTEX(dev); 620 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
618 621
619 /* Shift and mask out PDRIVE bits */ 622 /* Shift and mask out PDRIVE bits */
620 val = (val >> 4) & 0b00000011; 623 val = (val >> 4) & 0b00000011;
621 624
622 return val; 625 return val;
623 } 626 }
624 627
625 628
626 esp_err_t apds9930_setProximityDiode(i2c_dev_t *dev, uint8_t drive) 629 esp_err_t apds9930_setProximityDiode(apds9930_t *dev, uint8_t drive)
627 { 630 {
628 uint8_t val; 631 uint8_t val;
629 632
630 /* Read value from CONTROL register */ 633 /* Read value from CONTROL register */
631 I2C_DEV_TAKE_MUTEX(dev); 634 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
632 CHECK_LOGE(dev, i2c_dev_read_reg(dev, APDS9930_CONTROL, &val, 1), "Read control"); 635 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Read control");
633 636
634 /* Set bits in register to given value */ 637 /* Set bits in register to given value */
635 drive &= 0b00000011; 638 drive &= 0b00000011;
636 drive = drive << 4; 639 drive = drive << 4;
637 val &= 0b11001111; 640 val &= 0b11001111;
638 val |= drive; 641 val |= drive;
639 642
640 /* Write register value back into CONTROL register */ 643 /* Write register value back into CONTROL register */
641 CHECK_LOGE(dev, i2c_dev_write_reg(dev, APDS9930_CONTROL, &val, 1), "Write control"); 644 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Write control");
642 I2C_DEV_GIVE_MUTEX(dev); 645 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
643 646
644 return ESP_OK; 647 return ESP_OK;
645 } 648 }
646 649
647 650
648 uint8_t apds9930_getAmbientLightGain(i2c_dev_t *dev) 651 uint8_t apds9930_getAmbientLightGain(apds9930_t *dev)
649 { 652 {
650 uint8_t val; 653 uint8_t val;
651 654
652 /* Read value from CONTROL register */ 655 /* Read value from CONTROL register */
653 I2C_DEV_TAKE_MUTEX(dev); 656 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
654 if (i2c_dev_read_reg(dev, APDS9930_CONTROL, &val, 1) != ESP_OK) { 657 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1) != ESP_OK) {
655 I2C_DEV_GIVE_MUTEX(dev); 658 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
656 return APDS9930_ERROR;; 659 return APDS9930_ERROR;;
657 } 660 }
658 I2C_DEV_GIVE_MUTEX(dev); 661 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
659 662
660 /* Shift and mask out ADRIVE bits */ 663 /* Shift and mask out ADRIVE bits */
661 val &= 0b00000011; 664 val &= 0b00000011;
662 665
663 return val; 666 return val;
664 } 667 }
665 668
666 669
667 esp_err_t apds9930_setAmbientLightGain(i2c_dev_t *dev, uint8_t drive) 670 esp_err_t apds9930_setAmbientLightGain(apds9930_t *dev, uint8_t drive)
668 { 671 {
669 uint8_t val; 672 uint8_t val;
670 673
671 /* Read value from CONTROL register */ 674 /* Read value from CONTROL register */
672 I2C_DEV_TAKE_MUTEX(dev); 675 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
673 CHECK_LOGE(dev, i2c_dev_read_reg(dev, APDS9930_CONTROL, &val, 1), "Read control"); 676 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Read control");
674 677
675 /* Set bits in register to given value */ 678 /* Set bits in register to given value */
676 drive &= 0b00000011; 679 drive &= 0b00000011;
677 val &= 0b11111100; 680 val &= 0b11111100;
678 val |= drive; 681 val |= drive;
679 682
680 /* Write register value back into CONTROL register */ 683 /* Write register value back into CONTROL register */
681 CHECK_LOGE(dev, i2c_dev_write_reg(dev, APDS9930_CONTROL, &val, 1), "Write control"); 684 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Write control");
682 I2C_DEV_GIVE_MUTEX(dev); 685 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
683 686
684 return true; 687 return true;
685 } 688 }
686 689
687 690
688 uint8_t apds9930_getAmbientGainLevel(i2c_dev_t *dev) 691 uint8_t apds9930_getAmbientGainLevel(apds9930_t *dev)
689 { 692 {
690 uint8_t val; 693 uint8_t val;
691 694
692 /* Read value from CONTROL register */ 695 /* Read value from CONTROL register */
693 I2C_DEV_TAKE_MUTEX(dev); 696 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
694 if (i2c_dev_read_reg(dev, APDS9930_CONTROL, &val, 1) != ESP_OK) { 697 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1) != ESP_OK) {
695 I2C_DEV_GIVE_MUTEX(dev); 698 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
696 return APDS9930_ERROR;; 699 return APDS9930_ERROR;;
697 } 700 }
698 I2C_DEV_GIVE_MUTEX(dev); 701 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
699 702
700 /* Shift and mask out AGL bit */ 703 /* Shift and mask out AGL bit */
701 val = (val >> 2) & 0b00000001; 704 val = (val >> 2) & 0b00000001;
702 705
703 return val; 706 return val;
704 } 707 }
705 708
706 709
707 esp_err_t apds9930_setAmbientGainLevel(i2c_dev_t *dev, uint8_t enable) 710 esp_err_t apds9930_setAmbientGainLevel(apds9930_t *dev, uint8_t enable)
708 { 711 {
709 uint8_t val; 712 uint8_t val;
710 713
711 /* Read value from CONTROL register */ 714 /* Read value from CONTROL register */
712 I2C_DEV_TAKE_MUTEX(dev); 715 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
713 CHECK_LOGE(dev, i2c_dev_read_reg(dev, APDS9930_CONTROL, &val, 1), "Read control"); 716 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Read control");
714 717
715 /* Set bits in register to given value */ 718 /* Set bits in register to given value */
716 enable &= 0b00000001; 719 enable &= 0b00000001;
717 enable = enable << 2; 720 enable = enable << 2;
718 val &= 0b11111011; 721 val &= 0b11111011;
719 val |= enable; 722 val |= enable;
720 723
721 /* Write register value back into CONTROL register */ 724 /* Write register value back into CONTROL register */
722 CHECK_LOGE(dev, i2c_dev_write_reg(dev, APDS9930_CONTROL, &val, 1), "Write control"); 725 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_CONTROL, &val, 1), "Write control");
723 I2C_DEV_GIVE_MUTEX(dev); 726 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
724 727
725 return ESP_OK; 728 return ESP_OK;
726 } 729 }
727 730
728 731
729 esp_err_t apds9930_getLightIntLowThreshold(i2c_dev_t *dev, uint16_t *threshold) 732 esp_err_t apds9930_getLightIntLowThreshold(apds9930_t *dev, uint16_t *threshold)
730 { 733 {
731 uint8_t val_byte; 734 uint8_t val_byte;
732 *threshold = 0; 735 *threshold = 0;
733 736
734 /* Read value from ambient light low threshold, low byte register */ 737 /* Read value from ambient light low threshold, low byte register */
735 I2C_DEV_TAKE_MUTEX(dev); 738 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
736 if (i2c_dev_read_reg(dev, APDS9930_AILTL, &val_byte, 1) != ESP_OK) { 739 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_AILTL, &val_byte, 1) != ESP_OK) {
737 *threshold = 0; 740 *threshold = 0;
738 } 741 }
739 *threshold = val_byte; 742 *threshold = val_byte;
740 if (i2c_dev_read_reg(dev, APDS9930_AILTH, &val_byte, 1) != ESP_OK) { 743 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_AILTH, &val_byte, 1) != ESP_OK) {
741 *threshold = 0; 744 *threshold = 0;
742 } 745 }
743 I2C_DEV_GIVE_MUTEX(dev); 746 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
744 *threshold = *threshold + ((uint16_t)val_byte << 8); 747 *threshold = *threshold + ((uint16_t)val_byte << 8);
745 748
746 return ESP_OK; 749 return ESP_OK;
747 } 750 }
748 751
749 752
750 esp_err_t apds9930_setLightIntLowThreshold(i2c_dev_t *dev, uint16_t threshold) 753 esp_err_t apds9930_setLightIntLowThreshold(apds9930_t *dev, uint16_t threshold)
751 { 754 {
752 uint8_t val_low; 755 uint8_t val_low;
753 uint8_t val_high; 756 uint8_t val_high;
754 757
755 /* Break 16-bit threshold into 2 8-bit values */ 758 /* Break 16-bit threshold into 2 8-bit values */
756 val_low = threshold & 0x00FF; 759 val_low = threshold & 0x00FF;
757 val_high = (threshold & 0xFF00) >> 8; 760 val_high = (threshold & 0xFF00) >> 8;
758 761
759 I2C_DEV_TAKE_MUTEX(dev); 762 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
760 CHECK_LOGE(dev, i2c_dev_write_reg(dev, APDS9930_AILTL, &val_low, 1), "Write AILTL"); 763 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_AILTL, &val_low, 1), "Write AILTL");
761 CHECK_LOGE(dev, i2c_dev_write_reg(dev, APDS9930_AILTH, &val_high, 1), "Write AILTH"); 764 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_AILTH, &val_high, 1), "Write AILTH");
762 I2C_DEV_GIVE_MUTEX(dev); 765 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
763 766
764 return ESP_OK; 767 return ESP_OK;
765 } 768 }
766 769
767 770
768 esp_err_t apds9930_getLightIntHighThreshold(i2c_dev_t *dev, uint16_t *threshold) 771 esp_err_t apds9930_getLightIntHighThreshold(apds9930_t *dev, uint16_t *threshold)
769 { 772 {
770 uint8_t val_byte; 773 uint8_t val_byte;
771 *threshold = 0; 774 *threshold = 0;
772 775
773 /* Read value from ambient light high threshold, low byte register */ 776 /* Read value from ambient light high threshold, low byte register */
774 I2C_DEV_TAKE_MUTEX(dev); 777 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
775 if (i2c_dev_read_reg(dev, APDS9930_AIHTL, &val_byte, 1) != ESP_OK) { 778 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_AIHTL, &val_byte, 1) != ESP_OK) {
776 *threshold = 0; 779 *threshold = 0;
777 } 780 }
778 *threshold = val_byte; 781 *threshold = val_byte;
779 if (i2c_dev_read_reg(dev, APDS9930_AIHTH, &val_byte, 1) != ESP_OK) { 782 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_AIHTH, &val_byte, 1) != ESP_OK) {
780 *threshold = 0; 783 *threshold = 0;
781 } 784 }
782 I2C_DEV_GIVE_MUTEX(dev); 785 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
783 *threshold = *threshold + ((uint16_t)val_byte << 8); 786 *threshold = *threshold + ((uint16_t)val_byte << 8);
784 787
785 return ESP_OK; 788 return ESP_OK;
786 } 789 }
787 790
788 791
789 esp_err_t apds9930_setLightIntHighThreshold(i2c_dev_t *dev, uint16_t threshold) 792 esp_err_t apds9930_setLightIntHighThreshold(apds9930_t *dev, uint16_t threshold)
790 { 793 {
791 uint8_t val_low; 794 uint8_t val_low;
792 uint8_t val_high; 795 uint8_t val_high;
793 796
794 /* Break 16-bit threshold into 2 8-bit values */ 797 /* Break 16-bit threshold into 2 8-bit values */
795 val_low = threshold & 0x00FF; 798 val_low = threshold & 0x00FF;
796 val_high = (threshold & 0xFF00) >> 8; 799 val_high = (threshold & 0xFF00) >> 8;
797 800
798 I2C_DEV_TAKE_MUTEX(dev); 801 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
799 CHECK_LOGE(dev, i2c_dev_write_reg(dev, APDS9930_AIHTL, &val_low, 1), "Write AIHTL"); 802 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_AIHTL, &val_low, 1), "Write AIHTL");
800 CHECK_LOGE(dev, i2c_dev_write_reg(dev, APDS9930_AIHTH, &val_high, 1), "Write AIHTH"); 803 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_AIHTH, &val_high, 1), "Write AIHTH");
801 I2C_DEV_GIVE_MUTEX(dev); 804 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
802 805
803 return ESP_OK; 806 return ESP_OK;
804 } 807 }
805 808
806 809
807 uint8_t apds9930_getAmbientLightIntEnable(i2c_dev_t *dev) 810 uint8_t apds9930_getAmbientLightIntEnable(apds9930_t *dev)
808 { 811 {
809 uint8_t val; 812 uint8_t val;
810 813
811 /* Read value from ENABLE register */ 814 /* Read value from ENABLE register */
812 I2C_DEV_TAKE_MUTEX(dev); 815 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
813 if (i2c_dev_read_reg(dev, APDS9930_ENABLE, &val, 1) != ESP_OK) { 816 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_ENABLE, &val, 1) != ESP_OK) {
814 I2C_DEV_GIVE_MUTEX(dev); 817 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
815 return APDS9930_ERROR;; 818 return APDS9930_ERROR;;
816 } 819 }
817 I2C_DEV_GIVE_MUTEX(dev); 820 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
818 821
819 /* Shift and mask out AIEN bit */ 822 /* Shift and mask out AIEN bit */
820 val = (val >> 4) & 0b00000001; 823 val = (val >> 4) & 0b00000001;
821 824
822 return val; 825 return val;
823 } 826 }
824 827
825 828
826 esp_err_t apds9930_setAmbientLightIntEnable(i2c_dev_t *dev, uint8_t enable) 829 esp_err_t apds9930_setAmbientLightIntEnable(apds9930_t *dev, uint8_t enable)
827 { 830 {
828 uint8_t val; 831 uint8_t val;
829 832
830 /* Read value from ENABLE register */ 833 /* Read value from ENABLE register */
831 I2C_DEV_TAKE_MUTEX(dev); 834 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
832 CHECK_LOGE(dev, i2c_dev_read_reg(dev, APDS9930_ENABLE, &val, 1), "Read enable"); 835 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_ENABLE, &val, 1), "Read enable");
833 836
834 /* Set bits in register to given value */ 837 /* Set bits in register to given value */
835 enable &= 0b00000001; 838 enable &= 0b00000001;
836 enable = enable << 4; 839 enable = enable << 4;
837 val &= 0b11101111; 840 val &= 0b11101111;
838 val |= enable; 841 val |= enable;
839 842
840 /* Write register value back into ENABLE register */ 843 /* Write register value back into ENABLE register */
841 CHECK_LOGE(dev, i2c_dev_write_reg(dev, APDS9930_ENABLE, &val, 1), "Write enable"); 844 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_ENABLE, &val, 1), "Write enable");
842 I2C_DEV_GIVE_MUTEX(dev); 845 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
843 846
844 return ESP_OK; 847 return ESP_OK;
845 } 848 }
846 849
847 850
848 uint8_t apds9930_getProximityIntEnable(i2c_dev_t *dev) 851 uint8_t apds9930_getProximityIntEnable(apds9930_t *dev)
849 { 852 {
850 uint8_t val; 853 uint8_t val;
851 854
852 /* Read value from ENABLE register */ 855 /* Read value from ENABLE register */
853 I2C_DEV_TAKE_MUTEX(dev); 856 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
854 if (i2c_dev_read_reg(dev, APDS9930_ENABLE, &val, 1) != ESP_OK) { 857 if (i2c_dev_read_reg(&dev->i2c_dev, APDS9930_ENABLE, &val, 1) != ESP_OK) {
855 I2C_DEV_GIVE_MUTEX(dev); 858 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
856 return APDS9930_ERROR;; 859 return APDS9930_ERROR;;
857 } 860 }
858 I2C_DEV_GIVE_MUTEX(dev); 861 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
859 862
860 /* Shift and mask out PIEN bit */ 863 /* Shift and mask out PIEN bit */
861 val = (val >> 5) & 0b00000001; 864 val = (val >> 5) & 0b00000001;
862 865
863 return val; 866 return val;
864 } 867 }
865 868
866 869
867 esp_err_t apds9930_setProximityIntEnable(i2c_dev_t *dev, uint8_t enable) 870 esp_err_t apds9930_setProximityIntEnable(apds9930_t *dev, uint8_t enable)
868 { 871 {
869 uint8_t val; 872 uint8_t val;
870 873
871 /* Read value from ENABLE register */ 874 /* Read value from ENABLE register */
872 I2C_DEV_TAKE_MUTEX(dev); 875 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
873 CHECK_LOGE(dev, i2c_dev_read_reg(dev, APDS9930_ENABLE, &val, 1), "Read enable"); 876 CHECK_LOGE(dev, i2c_dev_read_reg(&dev->i2c_dev, APDS9930_ENABLE, &val, 1), "Read enable");
874 877
875 /* Set bits in register to given value */ 878 /* Set bits in register to given value */
876 enable &= 0b00000001; 879 enable &= 0b00000001;
877 enable = enable << 5; 880 enable = enable << 5;
878 val &= 0b11011111; 881 val &= 0b11011111;
879 val |= enable; 882 val |= enable;
880 883
881 /* Write register value back into ENABLE register */ 884 /* Write register value back into ENABLE register */
882 CHECK_LOGE(dev, i2c_dev_write_reg(dev, APDS9930_ENABLE, &val, 1), "Write enable"); 885 CHECK_LOGE(dev, i2c_dev_write_reg(&dev->i2c_dev, APDS9930_ENABLE, &val, 1), "Write enable");
883 I2C_DEV_GIVE_MUTEX(dev); 886 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
884 887
885 return ESP_OK; 888 return ESP_OK;
886 } 889 }
887 890
888 891
889 esp_err_t apds9930_clearAmbientLightInt(i2c_dev_t *dev) 892 esp_err_t apds9930_clearAmbientLightInt(apds9930_t *dev)
890 { 893 {
891 uint8_t val = APDS9930_CLEAR_ALS_INT; 894 uint8_t val = APDS9930_CLEAR_ALS_INT;
892 895
893 I2C_DEV_TAKE_MUTEX(dev); 896 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
894 /* This should write to the chip without register address */ 897 /* This should write to the chip without register address */
895 CHECK_LOGE(dev, i2c_dev_write(dev, NULL, 0, &val, 1), "Clear ALS_INT"); 898 CHECK_LOGE(dev, i2c_dev_write(&dev->i2c_dev, NULL, 0, &val, 1), "Clear ALS_INT");
896 I2C_DEV_GIVE_MUTEX(dev); 899 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
897 900
898 // if( !wireWriteByte(CLEAR_ALS_INT) ) { 901 // if( !wireWriteByte(CLEAR_ALS_INT) ) {
899 // return false; 902 // return false;
900 //} 903 //}
901 904
902 return ESP_OK; 905 return ESP_OK;
903 } 906 }
904 907
905 908
906 esp_err_t apds9930_clearProximityInt(i2c_dev_t *dev) 909 esp_err_t apds9930_clearProximityInt(apds9930_t *dev)
907 { 910 {
908 uint8_t val = APDS9930_CLEAR_PROX_INT; 911 uint8_t val = APDS9930_CLEAR_PROX_INT;
909 912
910 I2C_DEV_TAKE_MUTEX(dev); 913 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
911 CHECK_LOGE(dev, i2c_dev_write(dev, NULL, 0, &val, 1), "Clear PROX_INT"); 914 CHECK_LOGE(dev, i2c_dev_write(&dev->i2c_dev, NULL, 0, &val, 1), "Clear PROX_INT");
912 I2C_DEV_GIVE_MUTEX(dev); 915 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
913 916
914 return ESP_OK; 917 return ESP_OK;
915 } 918 }
916 919
917 920
918 esp_err_t apds9930_clearAllInts(i2c_dev_t *dev) 921 esp_err_t apds9930_clearAllInts(apds9930_t *dev)
919 { 922 {
920 uint8_t val = APDS9930_CLEAR_ALL_INTS; 923 uint8_t val = APDS9930_CLEAR_ALL_INTS;
921 924
922 I2C_DEV_TAKE_MUTEX(dev); 925 I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
923 CHECK_LOGE(dev, i2c_dev_write(dev, NULL, 0, &val, 1), "Clear ALL_INTS"); 926 CHECK_LOGE(dev, i2c_dev_write(&dev->i2c_dev, NULL, 0, &val, 1), "Clear ALL_INTS");
924 I2C_DEV_GIVE_MUTEX(dev); 927 I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);
925 928
926 return ESP_OK; 929 return ESP_OK;
927 } 930 }
928 931

Mercurial Repository: iotbalkon

mercurial