1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include "aos/kernel.h"
5 #include "sensor_drv_api.h"
6 #include "sensor_hal.h"
7
8
9 /*******************************************************************************
10 ********************************* MACROS **********************************
11 ******************************************************************************/
12 #define LTR303_ADDR_TRANS(n) ((n) << 1)
13 #define LTR303_GET_BITSLICE(uint8Val, bitName) (((uint8Val) & (LTR303_##bitName##__MSK)) >> (LTR303_##bitName##__POS))
14 #define LTR303_SET_BITSLICE(uint8Val, bitName, bitVal) (((uint8Val) & ~(LTR303_##bitName##__MSK)) | ((bitVal << (LTR303_##bitName##__POS)) & (LTR303_##bitName##__MSK)))
15
16 /*******************************************************************************
17 ************************** SENSOR SPECIFICATIONS **************************
18 ******************************************************************************/
19 /* I2C device address */
20 #define LTR303_SLAVE_ADDR (0x29)
21 #define LTR303_I2C_ADDR LTR303_ADDR_TRANS(LTR303_SLAVE_ADDR)
22
23 /* Device info */
24 #define LTR303_PART_ID_VAL 0xA0
25 #define LTR303_MANUFAC_ID_VAL 0x05
26
27 #define LTR303_WAIT_TIME_PER_CHECK (10)
28 #define LTR303_WAIT_TIME_TOTAL (100)
29
30 /*******************************************************************************
31 ************* Non-Configurable (Unless data sheet is updated) *************
32 ******************************************************************************/
33 /* Device register set address */
34 #define LTR303_ALS_CONTR_REG (0x80)
35 #define LTR303_ALS_MEAS_RATE_REG (0x85)
36 #define LTR303_PART_ID_REG (0x86)
37 #define LTR303_MANUFAC_ID_REG (0x87)
38 #define LTR303_ALS_DATA_CH1_0_REG (0x88)
39 #define LTR303_ALS_DATA_CH1_1_REG (0x89)
40 #define LTR303_ALS_DATA_CH0_0_REG (0x8A)
41 #define LTR303_ALS_DATA_CH0_1_REG (0x8B)
42 #define LTR303_ALS_STATUS_REG (0x8C)
43 #define LTR303_INTERRUPT_REG (0x8F)
44 #define LTR303_ALS_THRES_UP_0_REG (0x97)
45 #define LTR303_ALS_THRES_UP_1_REG (0x98)
46 #define LTR303_ALS_THRES_LOW_0_REG (0x99)
47 #define LTR303_ALS_THRES_LOW_1_REG (0x9A)
48 #define LTR303_INTERRUPT_PERSIST_REG (0x9E)
49
50 /* Register ALS_CONTR field */
51 #define LTR303_ALS_MODE__REG (LTR303_ALS_CONTR_REG)
52 #define LTR303_ALS_MODE__POS (0)
53 #define LTR303_ALS_MODE__MSK (0x01)
54 #define LTR303_SW_RESET__REG (LTR303_ALS_CONTR_REG)
55 #define LTR303_SW_RESET__POS (1)
56 #define LTR303_SW_RESET__MSK (0x02)
57 #define LTR303_ALS_GAIN__REG (LTR303_ALS_CONTR_REG)
58 #define LTR303_ALS_GAIN__POS (2)
59 #define LTR303_ALS_GAIN__MSK (0x1C)
60
61 /* Register ALS_MEAS_RATE field */
62 #define LTR303_ALS_MEAS_RPT_RATE__REG (LTR303_ALS_MEAS_RATE_REG)
63 #define LTR303_ALS_MEAS_RPT_RATE__POS (0)
64 #define LTR303_ALS_MEAS_RPT_RATE__MSK (0x07)
65 #define LTR303_ALS_INTEG_TIME__REG (LTR303_ALS_MEAS_RATE_REG)
66 #define LTR303_ALS_INTEG_TIME__POS (3)
67 #define LTR303_ALS_INTEG_TIME__MSK (0x38)
68
69 /* Register PART_ID field */
70 #define LTR303_REVISION_ID__REG (LTR303_PART_ID_REG)
71 #define LTR303_REVISION_ID__POS (0)
72 #define LTR303_REVISION_ID__MSK (0x0F)
73 #define LTR303_PART_NUMBER_ID__REG (LTR303_PART_ID_REG)
74 #define LTR303_PART_NUMBER_ID__POS (4)
75 #define LTR303_PART_NUMBER_ID__MSK (0xF0)
76
77 /* Register MANUFAC_ID field */
78 #define LTR303_MANUFAC_ID__REG (LTR303_MANUFAC_ID_REG)
79 #define LTR303_MANUFAC_ID__POS (0)
80 #define LTR303_MANUFAC_ID__MSK (0xFF)
81
82 /* Register ALS_DATA field */
83 #define LTR303_ALS_DATA_CH1_0__REG (LTR303_ALS_DATA_CH1_0_REG)
84 #define LTR303_ALS_DATA_CH1_0__POS (0)
85 #define LTR303_ALS_DATA_CH1_0__MSK (0xFF)
86 #define LTR303_ALS_DATA_CH1_1__REG (LTR303_ALS_DATA_CH1_1_REG)
87 #define LTR303_ALS_DATA_CH1_1__POS (0)
88 #define LTR303_ALS_DATA_CH1_1__MSK (0xFF)
89 #define LTR303_ALS_DATA_CH0_0__REG (LTR303_ALS_DATA_CH0_0_REG)
90 #define LTR303_ALS_DATA_CH0_0__POS (0)
91 #define LTR303_ALS_DATA_CH0_0__MSK (0xFF)
92 #define LTR303_ALS_DATA_CH0_1__REG (LTR303_ALS_DATA_CH0_1_REG)
93 #define LTR303_ALS_DATA_CH0_1__POS (0)
94 #define LTR303_ALS_DATA_CH0_1__MSK (0xFF)
95
96 /* Register ALS_STATUS field */
97 #define LTR303_ALS_DATA_STATUS__REG (LTR303_ALS_STATUS_REG)
98 #define LTR303_ALS_DATA_STATUS__POS (2)
99 #define LTR303_ALS_DATA_STATUS__MSK (0x04)
100 #define LTR303_ALS_INT_STATUS__REG (LTR303_ALS_STATUS_REG)
101 #define LTR303_ALS_INT_STATUS__POS (3)
102 #define LTR303_ALS_INT_STATUS__MSK (0x08)
103 #define LTR303_ALS_GAIN_STATUS__REG (LTR303_ALS_STATUS_REG)
104 #define LTR303_ALS_GAIN_STATUS__POS (4)
105 #define LTR303_ALS_GAIN_STATUS__MSK (0x70)
106 #define LTR303_ALS_DATA_VALIDITY__REG (LTR303_ALS_STATUS_REG)
107 #define LTR303_ALS_DATA_VALIDITY__POS (7)
108 #define LTR303_ALS_DATA_VALIDITY__MSK (0x80)
109
110 /* Register INTERRUPT field */
111 #define LTR303_INT_MODE__REG (LTR303_INTERRUPT_REG)
112 #define LTR303_INT_MODE__POS (1)
113 #define LTR303_INT_MODE__MSK (0x02)
114 #define LTR303_INT_POLARITY__REG (LTR303_INTERRUPT_REG)
115 #define LTR303_INT_POLARITY__POS (2)
116 #define LTR303_INT_POLARITY__MSK (0x04)
117
118 /* Register ALS_THRES field */
119 #define LTR303_ALS_THRES_UP_0__REG (LTR303_ALS_THRES_UP_0_REG)
120 #define LTR303_ALS_THRES_UP_0__POS (0)
121 #define LTR303_ALS_THRES_UP_0__MSK (0xFF)
122 #define LTR303_ALS_THRES_UP_1__REG (LTR303_ALS_THRES_UP_1_REG)
123 #define LTR303_ALS_THRES_UP_1__POS (0)
124 #define LTR303_ALS_THRES_UP_1__MSK (0xFF)
125 #define LTR303_ALS_THRES_LOW_0__REG (LTR303_ALS_THRES_LOW_0_REG)
126 #define LTR303_ALS_THRES_LOW_0__POS (0)
127 #define LTR303_ALS_THRES_LOW_0__MSK (0xFF)
128 #define LTR303_ALS_THRES_LOW_1__REG (LTR303_ALS_THRES_LOW_1_REG)
129 #define LTR303_ALS_THRES_LOW_1__POS (0)
130 #define LTR303_ALS_THRES_LOW_1__MSK (0xFF)
131
132 /* Register INTERRUPT_PERSIST field */
133 #define LTR303_ALS_PERSIST__REG (LTR303_INTERRUPT_PERSIST_REG)
134 #define LTR303_ALS_PERSIST__POS (0)
135 #define LTR303_ALS_PERSIST__MSK (0x0F)
136
137 /* Field value enumeration */
138 typedef enum {
139 LTR303_ALS_STANDBY_MODE = 0x00,
140 LTR303_ALS_ACTIVE_MODE = 0x01,
141 } LTR303_ALS_MODE_VAL;
142
143 typedef enum {
144 LTR303_ALS_NO_RESET = 0x00,
145 LTR303_ALS_RESET = 0x01,
146 } LTR_303_SW_RESET_VAL;
147
148 typedef enum {
149 LTR303_ALS_GAIN_1x = 0x00, /* 1 lux to 64k lux (default) */
150 LTR303_ALS_GAIN_2x = 0x01, /* 0.5 lux to 32k lux */
151 LTR303_ALS_GAIN_4x = 0x02, /* 0.25 lux to 16k lux */
152 LTR303_ALS_GAIN_8x = 0x03, /* 0.125 lux to 8k lux */
153 LTR303_ALS_GAIN_48x = 0x06, /* 0.02 lux to 1.3k lux */
154 LTR303_ALS_GAIN_96x = 0x07, /* 0.01 lux to 600 lux */
155 } LTR303_ALS_Gain_VAL;
156
157 typedef enum {
158 LTR303_ALS_MEAS_RPT_RATE_50MS = 0x00,
159 LTR303_ALS_MEAS_RPT_RATE_100MS = 0x01,
160 LTR303_ALS_MEAS_RPT_RATE_200MS = 0x02,
161 LTR303_ALS_MEAS_RPT_RATE_500MS = 0x03,
162 LTR303_ALS_MEAS_RPT_RATE_1000MS = 0x04,
163 LTR303_ALS_MEAS_RPT_RATE_2000MS = 0x05,
164 } LTR303_ALS_MEAS_RPT_RATE_VAL;
165
166 typedef enum {
167 LTR303_ALS_INTEG_TIME_100MS = 0x00,
168 LTR303_ALS_INTEG_TIME_50MS = 0x01,
169 LTR303_ALS_INTEG_TIME_200MS = 0x02,
170 LTR303_ALS_INTEG_TIME_400MS = 0x03,
171 LTR303_ALS_INTEG_TIME_150MS = 0x04,
172 LTR303_ALS_INTEG_TIME_250MS = 0x05,
173 LTR303_ALS_INTEG_TIME_300MS = 0x06,
174 LTR303_ALS_INTEG_TIME_350MS = 0x07,
175 } LTR303_ALS_INTEG_TIME_VAL;
176
177 typedef enum {
178 LTR303_ALS_DATA_OLD = 0x00,
179 LTR303_ALS_DATA_NEW = 0x01,
180 } LTR303_ALS_DATA_STATUS_VAL;
181
182 typedef enum {
183 LTR303_ALS_INT_INACTIVE = 0x00,
184 LTR303_ALS_INT_ACTIVE = 0x01,
185 } LTR303_ALS_INT_STATUS_VAL;
186
187 typedef enum {
188 LTR303_ALS_DATA_VALID = 0x00,
189 LTR303_ALS_DATA_INVALID = 0x01,
190 } LTR303_ALS_DATA_VALIDITY_VAL;
191
192 typedef enum {
193 LTR303_INT_MODE_INACTIVE = 0x00,
194 LTR303_INT_MODE_ACTIVE = 0x01,
195 } LTR303_INT_MODE_VAL;
196
197 typedef enum {
198 LTR303_INT_POLARITY_ACTIVE_LO = 0x00,
199 LTR303_INT_POLARITY_ACTIVE_HI = 0x01,
200 } LTR303_INT_POLARITY_VAL;
201
202 typedef enum {
203 LTR303_ALS_PERSIST_EACH = 0x00,
204 LTR303_ALS_PERSIST_2_CONT = 0x01,
205 LTR303_ALS_PERSIST_16_CONT = 0x0F,
206 } LTR303_ALS_PERSIST_VAL;
207
208
209 i2c_dev_t ltr303_ctx = {
210 .port = 3,
211 .config.address_width = 8,
212 .config.freq = 100000,
213 .config.dev_addr = LTR303_I2C_ADDR,
214 };
215
216 static uint8_t g_init_bitwise = 0;
217
218
drv_als_liteon_ltr303_validate_id(i2c_dev_t * drv,uint8_t part_id,uint8_t manufac_id)219 static int drv_als_liteon_ltr303_validate_id(i2c_dev_t* drv, uint8_t part_id, uint8_t manufac_id)
220 {
221 int ret = 0;
222 uint8_t part_id_value = 0;
223 uint8_t manufac_id_value = 0;
224
225 if (drv == NULL) {
226 return -1;
227 }
228
229 ret = sensor_i2c_read(drv, LTR303_PART_ID_REG, &part_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
230 if (unlikely(ret)) {
231 return ret;
232 }
233
234 ret = sensor_i2c_read(drv, LTR303_MANUFAC_ID_REG, &manufac_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
235 if (unlikely(ret)) {
236 return ret;
237 }
238
239 if (part_id_value != part_id || manufac_id_value != manufac_id) {
240 return -1;
241 }
242
243 return 0;
244 }
245
drv_als_liteon_ltr303_set_power_mode(i2c_dev_t * drv,dev_power_mode_e mode)246 static int drv_als_liteon_ltr303_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
247 {
248 int ret = 0;
249 uint8_t dev_mode = 0;
250 uint8_t value = 0;
251
252 ret = sensor_i2c_read(drv, LTR303_ALS_CONTR_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
253 if (unlikely(ret)) {
254 return ret;
255 }
256
257 switch (mode) {
258 case DEV_POWER_OFF:
259 case DEV_SLEEP:
260 dev_mode = LTR303_SET_BITSLICE(value, ALS_MODE, LTR303_ALS_STANDBY_MODE);
261 break;
262 case DEV_POWER_ON:
263 dev_mode = LTR303_SET_BITSLICE(value, ALS_MODE, LTR303_ALS_ACTIVE_MODE);
264 break;
265 default:
266 return -1;
267 }
268
269 ret = sensor_i2c_write(drv, LTR303_ALS_CONTR_REG, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
270 if (unlikely(ret)) {
271 return ret;
272 }
273
274 return 0;
275 }
276
drv_als_liteon_ltr303_is_ready(i2c_dev_t * drv)277 UNUSED static int drv_als_liteon_ltr303_is_ready(i2c_dev_t* drv)
278 {
279 int ret = 0;
280 uint8_t value = 0;
281
282 ret = sensor_i2c_read(drv, LTR303_ALS_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
283 if (unlikely(ret)) {
284 return 0;
285 }
286
287 ret = (LTR303_GET_BITSLICE(value, ALS_DATA_STATUS) == LTR303_ALS_DATA_NEW) ? 1 : 0;
288
289 return ret;
290 }
291
292 /**************************************************************************//**
293 * @brief
294 * Configure the settings of the sensor.
295 * This function assumes that the 100ms wait time requirement
296 * after sensor power up has been fulfilled.
297 * @details
298 * 1. The function first sets ALS_MODE field to Standby mode.
299 * 2. Then it configures the corresponding registers to default configurations.
300 * @param[in] drv
301 * The I2C peripheral to use.
302 * @return
303 * 0 if configuration is successful, -1 otherwise.
304 *****************************************************************************/
drv_als_liteon_ltr303_set_default_config(i2c_dev_t * drv)305 static int drv_als_liteon_ltr303_set_default_config(i2c_dev_t* drv)
306 {
307 int ret = 0;
308 uint8_t value = 0;
309
310 /* Set ALS_MODE field to standby mode, no SW reset, and set ALS_GAIN field */
311 value = LTR303_SET_BITSLICE(value, ALS_MODE, LTR303_ALS_STANDBY_MODE);
312 value = LTR303_SET_BITSLICE(value, SW_RESET, LTR303_ALS_NO_RESET);
313 value = LTR303_SET_BITSLICE(value, ALS_GAIN, LTR303_ALS_GAIN_1x);
314 ret = sensor_i2c_write(drv, LTR303_ALS_CONTR_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
315 if (unlikely(ret)) {
316 return ret;
317 }
318
319 /* Set ALS_MEAS_RPT_RATE, ALS_INTEG_TIME fields */
320 value = 0;
321 value = LTR303_SET_BITSLICE(value, ALS_MEAS_RPT_RATE, LTR303_ALS_MEAS_RPT_RATE_500MS);
322 value = LTR303_SET_BITSLICE(value, ALS_INTEG_TIME, LTR303_ALS_INTEG_TIME_100MS);
323 ret = sensor_i2c_write(drv, LTR303_ALS_MEAS_RATE_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
324 if (unlikely(ret)) {
325 return ret;
326 }
327
328 /* Set INT_MODE, INT_POLARITY fields */
329 value = 0;
330 value = LTR303_SET_BITSLICE(value, INT_MODE, LTR303_INT_MODE_INACTIVE);
331 value = LTR303_SET_BITSLICE(value, INT_POLARITY, LTR303_INT_POLARITY_ACTIVE_LO);
332 ret = sensor_i2c_write(drv, LTR303_INTERRUPT_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
333 if (unlikely(ret)) {
334 return ret;
335 }
336
337 /* Set ALS_PERSIST fields */
338 value = 0;
339 value = LTR303_SET_BITSLICE(value, ALS_PERSIST, LTR303_ALS_PERSIST_EACH);
340 ret = sensor_i2c_write(drv, LTR303_INTERRUPT_PERSIST_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
341 if (unlikely(ret)) {
342 return ret;
343 }
344
345 return 0;
346 }
347
drv_als_liteon_ltr303_get_gain_val(i2c_dev_t * drv)348 static uint8_t drv_als_liteon_ltr303_get_gain_val(i2c_dev_t* drv)
349 {
350 uint8_t als_gain = 0, als_gain_val = 0;
351 bool ret = false;
352
353 ret = sensor_i2c_read(drv, LTR303_ALS_STATUS_REG, &als_gain, I2C_DATA_LEN, I2C_OP_RETRIES);
354 if (!unlikely(ret))
355 {
356 als_gain = LTR303_GET_BITSLICE(als_gain, ALS_GAIN_STATUS);
357 switch (als_gain)
358 {
359 case LTR303_ALS_GAIN_1x:
360 als_gain_val = 1;
361 break;
362 case LTR303_ALS_GAIN_2x:
363 als_gain_val = 2;
364 break;
365 case LTR303_ALS_GAIN_4x:
366 als_gain_val = 4;
367 break;
368 case LTR303_ALS_GAIN_8x:
369 als_gain_val = 8;
370 break;
371 case LTR303_ALS_GAIN_48x:
372 als_gain_val = 48;
373 break;
374 case LTR303_ALS_GAIN_96x:
375 als_gain_val = 96;
376 break;
377 default:
378 als_gain_val = 1;
379 break;
380 }
381 }
382 else
383 {
384 als_gain_val = 0;
385 }
386
387 return als_gain_val;
388 }
389
drv_als_liteon_ltr303_get_integ_time_val(i2c_dev_t * drv)390 static uint16_t drv_als_liteon_ltr303_get_integ_time_val(i2c_dev_t* drv)
391 {
392 uint16_t als_integ = 0, als_integ_val = 0;
393 bool ret = false;
394
395 ret = sensor_i2c_read(drv, LTR303_ALS_MEAS_RATE_REG, (uint8_t*)&als_integ, I2C_DATA_LEN, I2C_OP_RETRIES);
396 if (!unlikely(ret))
397 {
398 als_integ = LTR303_GET_BITSLICE(als_integ, ALS_INTEG_TIME);
399 switch (als_integ)
400 {
401 case LTR303_ALS_INTEG_TIME_100MS:
402 als_integ_val = 10;
403 break;
404 case LTR303_ALS_INTEG_TIME_50MS:
405 als_integ_val = 5;
406 break;
407 case LTR303_ALS_INTEG_TIME_200MS:
408 als_integ_val = 20;
409 break;
410 case LTR303_ALS_INTEG_TIME_400MS:
411 als_integ_val = 40;
412 break;
413 case LTR303_ALS_INTEG_TIME_150MS:
414 als_integ_val = 15;
415 break;
416 case LTR303_ALS_INTEG_TIME_250MS:
417 als_integ_val = 25;
418 break;
419 case LTR303_ALS_INTEG_TIME_300MS:
420 als_integ_val = 30;
421 break;
422 case LTR303_ALS_INTEG_TIME_350MS:
423 als_integ_val = 35;
424 break;
425 default:
426 als_integ_val = 10;
427 break;
428 }
429 }
430 else
431 {
432 als_integ_val = 0;
433 }
434
435 return als_integ_val;
436 }
437
drv_als_liteon_ltr303_irq_handle(void)438 static void drv_als_liteon_ltr303_irq_handle(void)
439 {
440 /* no handle so far */
441 }
442
drv_als_liteon_ltr303_open(void)443 static int drv_als_liteon_ltr303_open(void)
444 {
445 int ret = 0;
446
447 ret = drv_als_liteon_ltr303_set_power_mode(<r303_ctx, DEV_POWER_ON);
448 if (unlikely(ret)) {
449 return -1;
450 }
451
452 LOG("%s %s successfully \n", SENSOR_STR, __func__);
453 return 0;
454 }
455
drv_als_liteon_ltr303_close(void)456 static int drv_als_liteon_ltr303_close(void)
457 {
458 int ret = 0;
459
460 ret = drv_als_liteon_ltr303_set_power_mode(<r303_ctx, DEV_POWER_OFF);
461 if (unlikely(ret)) {
462 return -1;
463 }
464
465 LOG("%s %s successfully \n", SENSOR_STR, __func__);
466 return 0;
467 }
468
drv_als_liteon_ltr303_read(void * buf,size_t len)469 static int drv_als_liteon_ltr303_read(void *buf, size_t len)
470 {
471 int ret = 0;
472 size_t size;
473 uint8_t reg_ch1_data[2] = { 0 };
474 uint8_t reg_ch0_data[2] = { 0 };
475 uint32_t als_data_ch0 = 0, als_data_ch1 = 0, chRatio = 0, tmpCalc = 0;
476 uint16_t als_gain_val = 0, als_integ_time_val = 0;
477 als_data_t * pdata = (als_data_t *) buf;
478
479 if (buf == NULL){
480 return -1;
481 }
482
483 size = sizeof(als_data_t);
484 if (len < size){
485 return -1;
486 }
487
488 ret = sensor_i2c_read(<r303_ctx, LTR303_ALS_DATA_CH1_0_REG, ®_ch1_data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
489 if (unlikely(ret)) {
490 return -1;
491 }
492
493 ret = sensor_i2c_read(<r303_ctx, LTR303_ALS_DATA_CH1_1_REG, ®_ch1_data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
494 if (unlikely(ret)) {
495 return -1;
496 }
497
498 ret = sensor_i2c_read(<r303_ctx, LTR303_ALS_DATA_CH0_0_REG, ®_ch0_data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
499 if (unlikely(ret)) {
500 return -1;
501 }
502
503 ret = sensor_i2c_read(<r303_ctx, LTR303_ALS_DATA_CH0_1_REG, ®_ch0_data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
504 if (unlikely(ret)) {
505 return -1;
506 }
507
508 als_data_ch0 = ((uint16_t) reg_ch0_data[1] << 8 | reg_ch0_data[0]);
509 als_data_ch1 = ((uint16_t) reg_ch1_data[1] << 8 | reg_ch1_data[0]);
510
511 chRatio = (als_data_ch1 * 100) / (als_data_ch0 + als_data_ch1);
512 if (chRatio < 45)
513 {
514 tmpCalc = (1774 * als_data_ch0 + 1106 * als_data_ch1);
515 }
516 else if (chRatio >= 45 && chRatio < 64)
517 {
518 tmpCalc = (4279 * als_data_ch0 - 1955 * als_data_ch1);
519 }
520 else if (chRatio >= 64 && chRatio < 85)
521 {
522 tmpCalc = (593 * als_data_ch0 + 119 * als_data_ch1);
523 }
524 else
525 {
526 tmpCalc = 0;
527 }
528
529 als_gain_val = drv_als_liteon_ltr303_get_gain_val(<r303_ctx);
530 als_integ_time_val = drv_als_liteon_ltr303_get_integ_time_val(<r303_ctx);
531 if ((als_gain_val != 0) && (als_integ_time_val != 0))
532 {
533 pdata->lux = tmpCalc / als_gain_val / als_integ_time_val / 100;
534 }
535 else
536 {
537 pdata->lux = 0;
538 }
539 pdata->timestamp = aos_now_ms();
540
541 return (int) size;
542 }
543
drv_als_liteon_ltr303_write(const void * buf,size_t len)544 static int drv_als_liteon_ltr303_write(const void *buf, size_t len)
545 {
546 (void) buf;
547 (void) len;
548
549 return 0;
550 }
551
drv_als_liteon_ltr303_ioctl(int cmd,unsigned long arg)552 static int drv_als_liteon_ltr303_ioctl(int cmd, unsigned long arg)
553 {
554 int ret = 0;
555
556 switch (cmd) {
557 case SENSOR_IOCTL_SET_POWER: {
558 ret = drv_als_liteon_ltr303_set_power_mode(<r303_ctx, arg);
559 if (unlikely(ret)) {
560 return -1;
561 }
562 } break;
563 case SENSOR_IOCTL_GET_INFO: {
564 /* fill the dev info here */
565 dev_sensor_info_t *info = (dev_sensor_info_t *) arg;
566 info->vendor = DEV_SENSOR_VENDOR_LITEON;
567 info->model = "LTR303";
568 info->unit = lux;
569 } break;
570 default:
571 return -1;
572 }
573
574 LOG("%s %s successfully \n", SENSOR_STR, __func__);
575 return 0;
576 }
577
drv_als_liteon_ltr303_init(void)578 int drv_als_liteon_ltr303_init(void)
579 {
580 int ret = 0;
581 sensor_obj_t sensor_als;
582 memset(&sensor_als, 0, sizeof(sensor_als));
583
584 if (!g_init_bitwise) {
585 ret = drv_als_liteon_ltr303_validate_id(<r303_ctx, LTR303_PART_ID_VAL, LTR303_MANUFAC_ID_VAL);
586 if (unlikely(ret)) {
587 return -1;
588 }
589 }
590
591 if (!g_init_bitwise) {
592 /* fill the sensor_als obj parameters here */
593 sensor_als.path = dev_als_path;
594 sensor_als.tag = TAG_DEV_ALS;
595 sensor_als.io_port = I2C_PORT;
596 sensor_als.mode = DEV_POLLING;
597 sensor_als.power = DEV_POWER_OFF;
598 sensor_als.open = drv_als_liteon_ltr303_open;
599 sensor_als.close = drv_als_liteon_ltr303_close;
600 sensor_als.read = drv_als_liteon_ltr303_read;
601 sensor_als.write = drv_als_liteon_ltr303_write;
602 sensor_als.ioctl = drv_als_liteon_ltr303_ioctl;
603 sensor_als.irq_handle = drv_als_liteon_ltr303_irq_handle;
604
605 ret = sensor_create_obj(&sensor_als);
606 if (unlikely(ret)) {
607 return -1;
608 }
609
610 ret = drv_als_liteon_ltr303_set_default_config(<r303_ctx);
611 if (unlikely(ret)) {
612 return -1;
613 }
614
615 g_init_bitwise |= 1;
616 }
617
618 LOG("%s %s successfully \n", SENSOR_STR, __func__);
619 return 0;
620 }
621
622
623 SENSOR_DRV_ADD(drv_als_liteon_ltr303_init);
624
625