wimbeaumont Project / VEML7700

class to readout the VEML7700 light sensor via i2c

Dependents:   veml7700_tst

veml7700.cpp@0:e71d3ecdd257, 2019-09-10 (annotated)

Committer:
wbeaumont
Date:
Tue Sep 10 11:11:19 2019 +0000
Revision:
0:e71d3ecdd257
Child:
1:d6eb62dc0a1e
initial version for the VEML7700 light detector.  Basic methods implemented, tested with  FRDM-KL057

Who changed what in which revision?

UserRevisionLine numberNew contents of line
wbeaumont 0:e71d3ecdd257 1 #include "veml7700.h"
wbeaumont 0:e71d3ecdd257 2 //nclude <stdio.h>
wbeaumont 0:e71d3ecdd257 3 /**
wbeaumont 0:e71d3ecdd257 4 * veml7700.cpp
wbeaumont 0:e71d3ecdd257 5 * implementation of the veml7700 class , see veml7700.h
wbeaumont 0:e71d3ecdd257 6 *
wbeaumont 0:e71d3ecdd257 7 * version history
wbeaumont 0:e71d3ecdd257 8 * version 0.20 : initial value not tested with the sensor
wbeaumont 0:e71d3ecdd257 9 * version 0.21 : just change the name from VEML770 VEML7700
wbeaumont 0:e71d3ecdd257 10 corrected address
wbeaumont 0:e71d3ecdd257 11 * version 0.30 : start with error reporting
wbeaumont 0:e71d3ecdd257 12 * version 0.34 : correction
wbeaumont 0:e71d3ecdd257 13 * version 0.46 : corrections for correct working , more methods added
wbeaumont 0:e71d3ecdd257 14 * This file make part of the PeriperalDevice package see repository
wbeaumont 0:e71d3ecdd257 15 * https://github.com/wimbeaumont/PeripheralDevices
wbeaumont 0:e71d3ecdd257 16 *
wbeaumont 0:e71d3ecdd257 17 * (C) Wim Beaumont Universiteit Antwerpen 2015 2019
wbeaumont 0:e71d3ecdd257 18 * License see
wbeaumont 0:e71d3ecdd257 19 * https://github.com/wimbeaumont/PeripheralDevices/blob/master/LICENSE
wbeaumont 0:e71d3ecdd257 20 *
wbeaumont 0:e71d3ecdd257 21 **/
wbeaumont 0:e71d3ecdd257 22
wbeaumont 0:e71d3ecdd257 23 #define VERSION_VEML7700_SRC "0.49"
wbeaumont 0:e71d3ecdd257 24
wbeaumont 0:e71d3ecdd257 25 namespace VEML7700_CONST {
wbeaumont 0:e71d3ecdd257 26 // the VEML7700 support only 1 I2C address
wbeaumont 0:e71d3ecdd257 27 const int i2caddr = 0x20;
wbeaumont 0:e71d3ecdd257 28
wbeaumont 0:e71d3ecdd257 29 // registers
wbeaumont 0:e71d3ecdd257 30
wbeaumont 0:e71d3ecdd257 31 const u8 ALS_CONF_0 =0x0 ;
wbeaumont 0:e71d3ecdd257 32 const u8 ALS_WH =0x1 ;
wbeaumont 0:e71d3ecdd257 33 const u8 ALS_WL =0x2 ;
wbeaumont 0:e71d3ecdd257 34 const u8 POW_SET =0x3 ;
wbeaumont 0:e71d3ecdd257 35 const u8 ALS =0x4 ;
wbeaumont 0:e71d3ecdd257 36 const u8 WHITE =0x5 ;
wbeaumont 0:e71d3ecdd257 37 const u8 ALS_INT =0x6 ;
wbeaumont 0:e71d3ecdd257 38
wbeaumont 0:e71d3ecdd257 39
wbeaumont 0:e71d3ecdd257 40 // bit masks R0 and values
wbeaumont 0:e71d3ecdd257 41 const u16 ALS_SD_SIZE =0x1 ; //shutdown =1
wbeaumont 0:e71d3ecdd257 42 const u16 ALS_SD_LSB =0x0 ;
wbeaumont 0:e71d3ecdd257 43 const u16 ALS_INT_EN_SIZE =0x1 ; //enable =1
wbeaumont 0:e71d3ecdd257 44 const u16 ALS_INT_EN_LSB =0x1 ;
wbeaumont 0:e71d3ecdd257 45 const u16 ALS_PERS_SIZE =0x2 ;
wbeaumont 0:e71d3ecdd257 46 const u16 ALS_PERS_LSB =4 ;
wbeaumont 0:e71d3ecdd257 47 const u16 ALS_GAIN_SIZE =0x2 ;
wbeaumont 0:e71d3ecdd257 48 const u16 ALS_GAIN_LSB = 11;
wbeaumont 0:e71d3ecdd257 49 const u16 ALS_IT_SIZE =0x4;
wbeaumont 0:e71d3ecdd257 50 const u16 ALS_IT_LSB =6;
wbeaumont 0:e71d3ecdd257 51 const u16 RESERVED_BIT_MSK_ALS_CONF_0 = 0xE40C; // these bits should be 0 so use inverse with AND
wbeaumont 0:e71d3ecdd257 52
wbeaumont 0:e71d3ecdd257 53 const int NrGains =4;
wbeaumont 0:e71d3ecdd257 54
wbeaumont 0:e71d3ecdd257 55 // make array of struct for the next 2 ?
wbeaumont 0:e71d3ecdd257 56 u16 GainSets[NrGains] = { 0x2, 0x3 , 0x0 , 0x1 };
wbeaumont 0:e71d3ecdd257 57 float gains[NrGains] = {.125, .25 , 1, 2 };
wbeaumont 0:e71d3ecdd257 58
wbeaumont 0:e71d3ecdd257 59 const int NrIntT =6;
wbeaumont 0:e71d3ecdd257 60 u16 IntTSets[NrIntT]={ 0b1100,0b1000,0b0000,0b0001,0b0010,0b0011 };
wbeaumont 0:e71d3ecdd257 61 int IntTs[NrIntT] = { 25 ,50,100,200,400, 800 };
wbeaumont 0:e71d3ecdd257 62
wbeaumont 0:e71d3ecdd257 63
wbeaumont 0:e71d3ecdd257 64 // R1 and R2 are 16 words value
wbeaumont 0:e71d3ecdd257 65 // bit mask R3 and values
wbeaumont 0:e71d3ecdd257 66 const u16 RESERVED_BIT_MSK_POW_SET = 0xFFF8; // these bits should be 0 so use inverse with AND
wbeaumont 0:e71d3ecdd257 67 const u16 PSM_EN_SIZE =0x1 ;
wbeaumont 0:e71d3ecdd257 68 const u16 PSM_EN_LSB =0x0 ;
wbeaumont 0:e71d3ecdd257 69 const u16 PSM_SIZE =0x6 ;
wbeaumont 0:e71d3ecdd257 70 const u16 PSM_LSB =0x1 ;
wbeaumont 0:e71d3ecdd257 71
wbeaumont 0:e71d3ecdd257 72 // R4 and R5 are 16 words value
wbeaumont 0:e71d3ecdd257 73 // bit mask R6 and values status
wbeaumont 0:e71d3ecdd257 74
wbeaumont 0:e71d3ecdd257 75 const u16 INT_TH_HIGH_MSK =0x4000 ;
wbeaumont 0:e71d3ecdd257 76 const u16 INT_TH_LOW_MSK =0x8000 ;
wbeaumont 0:e71d3ecdd257 77 }
wbeaumont 0:e71d3ecdd257 78
wbeaumont 0:e71d3ecdd257 79 using namespace VEML7700_CONST;
wbeaumont 0:e71d3ecdd257 80
wbeaumont 0:e71d3ecdd257 81
wbeaumont 0:e71d3ecdd257 82
wbeaumont 0:e71d3ecdd257 83 VEML7700::VEML7700(I2CInterface* i2c , bool init )
wbeaumont 0:e71d3ecdd257 84 :getVersion( VERSION_VEML7700_HDR,VERSION_VEML7700_SRC, __TIME__, __DATE__),
wbeaumont 0:e71d3ecdd257 85 i2cdev(i2c) {
wbeaumont 0:e71d3ecdd257 86 i2cdev=i2c;
wbeaumont 0:e71d3ecdd257 87 gain_nr=0;
wbeaumont 0:e71d3ecdd257 88 IntTnr =0;
wbeaumont 0:e71d3ecdd257 89 if( init) {
wbeaumont 0:e71d3ecdd257 90 set_default_als_config();
wbeaumont 0:e71d3ecdd257 91 set_default_powermode();
wbeaumont 0:e71d3ecdd257 92 // don't care about the threshold settings are interrupt not used by default
wbeaumont 0:e71d3ecdd257 93 }
wbeaumont 0:e71d3ecdd257 94
wbeaumont 0:e71d3ecdd257 95 }
wbeaumont 0:e71d3ecdd257 96
wbeaumont 0:e71d3ecdd257 97 int VEML7700::get_status(void) {
wbeaumont 0:e71d3ecdd257 98 return i2cdev-> getLastComError() ;
wbeaumont 0:e71d3ecdd257 99
wbeaumont 0:e71d3ecdd257 100 }
wbeaumont 0:e71d3ecdd257 101
wbeaumont 0:e71d3ecdd257 102
wbeaumont 0:e71d3ecdd257 103 void VEML7700::setHighWarningLevel( int lvl){
wbeaumont 0:e71d3ecdd257 104 u16 llvl=(u16) lvl & 0xFF;
wbeaumont 0:e71d3ecdd257 105 write_cmd(ALS_WH, llvl);
wbeaumont 0:e71d3ecdd257 106 }
wbeaumont 0:e71d3ecdd257 107
wbeaumont 0:e71d3ecdd257 108 void VEML7700::setLowWarningLevel( int lvl){
wbeaumont 0:e71d3ecdd257 109 u16 llvl=(u16) lvl & 0xFF;
wbeaumont 0:e71d3ecdd257 110 write_cmd(ALS_WL, llvl);
wbeaumont 0:e71d3ecdd257 111 }
wbeaumont 0:e71d3ecdd257 112
wbeaumont 0:e71d3ecdd257 113 bool VEML7700::HighThresoldExeed(void) {
wbeaumont 0:e71d3ecdd257 114 return (INT_TH_HIGH_MSK & read_cmd(ALS_INT )) ? true:false;
wbeaumont 0:e71d3ecdd257 115 }
wbeaumont 0:e71d3ecdd257 116
wbeaumont 0:e71d3ecdd257 117 bool VEML7700::LowThresoldExeed(void){
wbeaumont 0:e71d3ecdd257 118 return (INT_TH_LOW_MSK & read_cmd(ALS_INT )) ? true:false;
wbeaumont 0:e71d3ecdd257 119 }
wbeaumont 0:e71d3ecdd257 120
wbeaumont 0:e71d3ecdd257 121
wbeaumont 0:e71d3ecdd257 122 void VEML7700::set_bits_reg ( u8 reg , u16 value, u16 lsb ,u16 bsize ) {
wbeaumont 0:e71d3ecdd257 123 u16 regvalue =read_cmd(reg );
wbeaumont 0:e71d3ecdd257 124 regvalue = set_bits(regvalue, value, lsb, bsize) ;
wbeaumont 0:e71d3ecdd257 125 if (reg == ALS_CONF_0) {regvalue &= ~RESERVED_BIT_MSK_ALS_CONF_0; }
wbeaumont 0:e71d3ecdd257 126 if (reg == POW_SET) {regvalue &= ~RESERVED_BIT_MSK_POW_SET; }
wbeaumont 0:e71d3ecdd257 127 write_cmd( reg, regvalue ) ;
wbeaumont 0:e71d3ecdd257 128 }
wbeaumont 0:e71d3ecdd257 129
wbeaumont 0:e71d3ecdd257 130 u16 VEML7700::set_bits(u16 regvalue, u16 value, u16 lsb ,u16 bsize ) {
wbeaumont 0:e71d3ecdd257 131 u16 mask = 1;
wbeaumont 0:e71d3ecdd257 132 mask = mask << bsize ; mask = mask -1; // so bsize=3 give now mask 0 0111
wbeaumont 0:e71d3ecdd257 133 mask = mask << lsb; // put the bits in the correct place
wbeaumont 0:e71d3ecdd257 134 regvalue &= ~mask; // set bits to 0
wbeaumont 0:e71d3ecdd257 135 value = value << lsb; // set the value bits in the correct place.
wbeaumont 0:e71d3ecdd257 136 value &= mask ; //only set these bits
wbeaumont 0:e71d3ecdd257 137 return value | regvalue;
wbeaumont 0:e71d3ecdd257 138 }
wbeaumont 0:e71d3ecdd257 139
wbeaumont 0:e71d3ecdd257 140 void VEML7700::shutdown( bool enable) {
wbeaumont 0:e71d3ecdd257 141 u16 ie= enable ? 0 :1 ;
wbeaumont 0:e71d3ecdd257 142 set_bits_reg( ALS_CONF_0,ie, ALS_SD_LSB,ALS_SD_SIZE );
wbeaumont 0:e71d3ecdd257 143 }
wbeaumont 0:e71d3ecdd257 144
wbeaumont 0:e71d3ecdd257 145 void VEML7700::set_int_enable( bool int_enable) {
wbeaumont 0:e71d3ecdd257 146 u16 ie= int_enable ? 0 :1 ;
wbeaumont 0:e71d3ecdd257 147 set_bits_reg( ALS_CONF_0,ie, ALS_INT_EN_LSB,ALS_INT_EN_SIZE );
wbeaumont 0:e71d3ecdd257 148 }
wbeaumont 0:e71d3ecdd257 149
wbeaumont 0:e71d3ecdd257 150 void VEML7700::set_gain_bits( u16 gbits ) {
wbeaumont 0:e71d3ecdd257 151 set_bits_reg ( ALS_CONF_0 , gbits , ALS_GAIN_LSB,ALS_GAIN_SIZE );
wbeaumont 0:e71d3ecdd257 152 }
wbeaumont 0:e71d3ecdd257 153
wbeaumont 0:e71d3ecdd257 154 void VEML7700::set_IntT_bits( u16 InTgbits ) {
wbeaumont 0:e71d3ecdd257 155 set_bits_reg ( ALS_CONF_0 , InTgbits , ALS_IT_LSB,ALS_IT_SIZE );
wbeaumont 0:e71d3ecdd257 156 }
wbeaumont 0:e71d3ecdd257 157
wbeaumont 0:e71d3ecdd257 158
wbeaumont 0:e71d3ecdd257 159 void VEML7700::set_default_als_config ( bool shutdown , bool int_enable ,u16 pres, u16 integrationtime, u16 gain ) {
wbeaumont 0:e71d3ecdd257 160 u16 setvalue = shutdown? 1:0; //set shutdown
wbeaumont 0:e71d3ecdd257 161 u16 uinterrupt= int_enable ?1:0;
wbeaumont 0:e71d3ecdd257 162 setvalue=set_bits( setvalue , uinterrupt , ALS_INT_EN_LSB,ALS_INT_EN_SIZE);
wbeaumont 0:e71d3ecdd257 163 setvalue=set_bits( setvalue , pres , ALS_PERS_LSB,ALS_PERS_SIZE);
wbeaumont 0:e71d3ecdd257 164 setvalue=set_bits( setvalue , integrationtime , ALS_IT_LSB,ALS_IT_SIZE);
wbeaumont 0:e71d3ecdd257 165 setvalue=set_bits( setvalue , gain , ALS_GAIN_LSB,ALS_GAIN_SIZE);
wbeaumont 0:e71d3ecdd257 166 setvalue &= ~RESERVED_BIT_MSK_ALS_CONF_0;
wbeaumont 0:e71d3ecdd257 167 write_cmd( ALS_CONF_0, setvalue ) ;// it will et all the bits so no need to read first
wbeaumont 0:e71d3ecdd257 168 }
wbeaumont 0:e71d3ecdd257 169
wbeaumont 0:e71d3ecdd257 170 void VEML7700::set_power_saving_enable( bool ps_enable) {
wbeaumont 0:e71d3ecdd257 171 u16 pse=ps_enable ? 0 :1 ;
wbeaumont 0:e71d3ecdd257 172 set_bits_reg( POW_SET ,pse, PSM_EN_LSB, PSM_EN_SIZE );
wbeaumont 0:e71d3ecdd257 173 }
wbeaumont 0:e71d3ecdd257 174
wbeaumont 0:e71d3ecdd257 175 void VEML7700::set_power_saving_mode( u16 psmode) {
wbeaumont 0:e71d3ecdd257 176 set_bits_reg( POW_SET ,psmode, PSM_LSB, PSM_SIZE );
wbeaumont 0:e71d3ecdd257 177 }
wbeaumont 0:e71d3ecdd257 178
wbeaumont 0:e71d3ecdd257 179 void VEML7700::set_default_powermode ( bool ps_enable , u16 psmode) {
wbeaumont 0:e71d3ecdd257 180 u16 setvalue = ps_enable ? 0:1;
wbeaumont 0:e71d3ecdd257 181 setvalue = set_bits( setvalue, psmode,PSM_LSB, PSM_SIZE );
wbeaumont 0:e71d3ecdd257 182 setvalue &= ~ ~RESERVED_BIT_MSK_POW_SET;
wbeaumont 0:e71d3ecdd257 183 write_cmd( POW_SET , setvalue ) ;
wbeaumont 0:e71d3ecdd257 184 }
wbeaumont 0:e71d3ecdd257 185
wbeaumont 0:e71d3ecdd257 186 // error handling via DevErrorReporter
wbeaumont 0:e71d3ecdd257 187 u16 VEML7700::read_cmd ( u8 reg) {
wbeaumont 0:e71d3ecdd257 188 /* seems this doesn work returns always zero
wbeaumont 0:e71d3ecdd257 189 printf("call read_cmd ");
wbeaumont 0:e71d3ecdd257 190 char readvalue[2]; // max 2 values read
wbeaumont 0:e71d3ecdd257 191 // first set the reg pointer . not sure if this works
wbeaumont 0:e71d3ecdd257 192 readvalue[0] = (char) reg;
wbeaumont 0:e71d3ecdd257 193 int err= i2cdev->write (i2caddr,readvalue, 1,false) ; // Write reg to an I2C slave. 3 words with stop
wbeaumont 0:e71d3ecdd257 194 if (err) { printf("VELM7700 %d i2c err %d in %d \n\r",err, __LINE__); }
wbeaumont 0:e71d3ecdd257 195 //now read
wbeaumont 0:e71d3ecdd257 196 err = i2cdev->read( i2caddr, readvalue , 2, false) ;// read from the i2c dev with stop
wbeaumont 0:e71d3ecdd257 197 if (err) {printf("VELM7700 %d i2c err %d in %d \n\r",err, __LINE__); }
wbeaumont 0:e71d3ecdd257 198 printf(" %x %x \n\r", (int) readvalue[0], (int) readvalue[1]);
wbeaumont 0:e71d3ecdd257 199 u16 rv= readvalue[1]; rv=rv<<8;
wbeaumont 0:e71d3ecdd257 200 rv|= readvalue[0];
wbeaumont 0:e71d3ecdd257 201 return rv;
wbeaumont 0:e71d3ecdd257 202 */
wbeaumont 0:e71d3ecdd257 203 char readvalue[2];
wbeaumont 0:e71d3ecdd257 204 i2cdev-> read_reg( i2caddr , readvalue , 2, (int) reg, 1);
wbeaumont 0:e71d3ecdd257 205 u16 rv= readvalue[1]; rv=rv<<8;
wbeaumont 0:e71d3ecdd257 206 rv|= readvalue[0];
wbeaumont 0:e71d3ecdd257 207 return rv;
wbeaumont 0:e71d3ecdd257 208
wbeaumont 0:e71d3ecdd257 209 }
wbeaumont 0:e71d3ecdd257 210
wbeaumont 0:e71d3ecdd257 211
wbeaumont 0:e71d3ecdd257 212
wbeaumont 0:e71d3ecdd257 213 // error handling via DevErrorReporter
wbeaumont 0:e71d3ecdd257 214 void VEML7700::write_cmd( u8 reg , u16 value ){
wbeaumont 0:e71d3ecdd257 215 char writevalue[3]; // max 3 values to write
wbeaumont 0:e71d3ecdd257 216 writevalue[0] = (char) reg;
wbeaumont 0:e71d3ecdd257 217 writevalue[1] = (char)( value & 0xFF); //Write LSByte first see data I2C interface
wbeaumont 0:e71d3ecdd257 218 value =value >>8;
wbeaumont 0:e71d3ecdd257 219 writevalue[2] = (char)( value & 0xFF); //MSByte
wbeaumont 0:e71d3ecdd257 220 i2cdev->write(i2caddr,writevalue, 3,false) ; // Write to an I2C slave. 3 words with stop
wbeaumont 0:e71d3ecdd257 221 }
wbeaumont 0:e71d3ecdd257 222
wbeaumont 0:e71d3ecdd257 223
wbeaumont 0:e71d3ecdd257 224 u16 VEML7700::get_IntT_in_set_bit( int time_ms) {
wbeaumont 0:e71d3ecdd257 225 for ( IntTnr= 0;IntTnr <NrIntT ;IntTnr++){
wbeaumont 0:e71d3ecdd257 226 if( time_ms < IntTs[IntTnr] ) break;
wbeaumont 0:e71d3ecdd257 227 }
wbeaumont 0:e71d3ecdd257 228 if( IntTnr == NrIntT ) { IntTnr--;}
wbeaumont 0:e71d3ecdd257 229 return IntTSets[IntTnr];
wbeaumont 0:e71d3ecdd257 230 }
wbeaumont 0:e71d3ecdd257 231
wbeaumont 0:e71d3ecdd257 232 void VEML7700::set_integrationtime( int time_ms ) {
wbeaumont 0:e71d3ecdd257 233 u16 gb=get_IntT_in_set_bit( time_ms);
wbeaumont 0:e71d3ecdd257 234 set_IntT_bits( gb);
wbeaumont 0:e71d3ecdd257 235 }
wbeaumont 0:e71d3ecdd257 236
wbeaumont 0:e71d3ecdd257 237
wbeaumont 0:e71d3ecdd257 238 void VEML7700::set_gain( float gain ) {
wbeaumont 0:e71d3ecdd257 239 u16 gb= get_gain_in_set_bit ( gain );
wbeaumont 0:e71d3ecdd257 240 set_gain_bits( gb);
wbeaumont 0:e71d3ecdd257 241 }
wbeaumont 0:e71d3ecdd257 242
wbeaumont 0:e71d3ecdd257 243
wbeaumont 0:e71d3ecdd257 244 u16 VEML7700::get_gain_in_set_bit (float gainsel ) {
wbeaumont 0:e71d3ecdd257 245 for ( gain_nr = 0; gain_nr < NrGains; gain_nr++ ){
wbeaumont 0:e71d3ecdd257 246 if ( gainsel <= gains[gain_nr] ) { break;}
wbeaumont 0:e71d3ecdd257 247 }
wbeaumont 0:e71d3ecdd257 248 if( gain_nr == NrGains) { gain_nr--;};
wbeaumont 0:e71d3ecdd257 249 return GainSets[gain_nr];
wbeaumont 0:e71d3ecdd257 250 }
wbeaumont 0:e71d3ecdd257 251
wbeaumont 0:e71d3ecdd257 252
wbeaumont 0:e71d3ecdd257 253 u16 VEML7700::get_als_bits(void){
wbeaumont 0:e71d3ecdd257 254 return read_cmd(ALS );
wbeaumont 0:e71d3ecdd257 255 }
wbeaumont 0:e71d3ecdd257 256
wbeaumont 0:e71d3ecdd257 257 u16 VEML7700::get_white_ch_bits(void){
wbeaumont 0:e71d3ecdd257 258 return read_cmd(WHITE );
wbeaumont 0:e71d3ecdd257 259 }
wbeaumont 0:e71d3ecdd257 260 // below are not necessay but useful fpr debugging
wbeaumont 0:e71d3ecdd257 261 u16 VEML7700::get_bits(u16 regvalue, u16 lsb ,u16 bsize ) {
wbeaumont 0:e71d3ecdd257 262 u16 mask = 1;
wbeaumont 0:e71d3ecdd257 263 mask = mask << bsize ; mask = mask -1; // so bsize=3 give now mask 0 0111
wbeaumont 0:e71d3ecdd257 264 mask = mask << lsb; // put the bits in the correct place
wbeaumont 0:e71d3ecdd257 265 regvalue &= mask ; //truncate if to big
wbeaumont 0:e71d3ecdd257 266 mask = 1;
wbeaumont 0:e71d3ecdd257 267 mask = mask << bsize ; mask = mask -1; // so bsize=3 give now mask 0 0111
wbeaumont 0:e71d3ecdd257 268 regvalue = regvalue >> lsb; // set the value bits in the correct place.
wbeaumont 0:e71d3ecdd257 269 return regvalue & mask;
wbeaumont 0:e71d3ecdd257 270 }
wbeaumont 0:e71d3ecdd257 271
wbeaumont 0:e71d3ecdd257 272 float VEML7700::decodeGainBits( u16 gb) {
wbeaumont 0:e71d3ecdd257 273 int g_nr ; float rv=0;
wbeaumont 0:e71d3ecdd257 274 for ( g_nr = 0; g_nr < NrGains; g_nr++ ){
wbeaumont 0:e71d3ecdd257 275 if ( gb == GainSets[g_nr] ) { break;}
wbeaumont 0:e71d3ecdd257 276 }
wbeaumont 0:e71d3ecdd257 277 if( g_nr < NrGains) { rv = gains[gain_nr];};
wbeaumont 0:e71d3ecdd257 278 // else not valid gain setting , return 0
wbeaumont 0:e71d3ecdd257 279 return rv;
wbeaumont 0:e71d3ecdd257 280 }
wbeaumont 0:e71d3ecdd257 281
wbeaumont 0:e71d3ecdd257 282 int VEML7700::decodeIntTbits( u16 ib ) {
wbeaumont 0:e71d3ecdd257 283 int In_nr, rv=0;
wbeaumont 0:e71d3ecdd257 284 for ( In_nr= 0;In_nr < NrIntT ;In_nr++){
wbeaumont 0:e71d3ecdd257 285 if( ib == IntTSets[In_nr] ){ break;}
wbeaumont 0:e71d3ecdd257 286 }
wbeaumont 0:e71d3ecdd257 287 if ( In_nr < NrIntT) { rv =IntTs[In_nr]; };
wbeaumont 0:e71d3ecdd257 288 //else not valid Integration bit code return 0
wbeaumont 0:e71d3ecdd257 289 return rv ;
wbeaumont 0:e71d3ecdd257 290 }
wbeaumont 0:e71d3ecdd257 291
wbeaumont 0:e71d3ecdd257 292 void VEML7700::decode_Reg0( bool& sd ,bool& ie, u16& pers_protect,int& IntT, float& gain ) {
wbeaumont 0:e71d3ecdd257 293 u16 reg= read_cmd(ALS_CONF_0);
wbeaumont 0:e71d3ecdd257 294 u16 res= get_bits(reg, ALS_SD_LSB , ALS_SD_SIZE ) ;
wbeaumont 0:e71d3ecdd257 295 sd = reg ? false : true;
wbeaumont 0:e71d3ecdd257 296 res= get_bits(reg,ALS_INT_EN_LSB , ALS_INT_EN_SIZE ) ;
wbeaumont 0:e71d3ecdd257 297 ie = reg ? false : true;
wbeaumont 0:e71d3ecdd257 298 pers_protect= get_bits(reg,ALS_PERS_LSB , ALS_PERS_SIZE ) ;
wbeaumont 0:e71d3ecdd257 299 res= get_bits(reg,ALS_IT_LSB , ALS_IT_SIZE ) ;
wbeaumont 0:e71d3ecdd257 300 IntT=decodeIntTbits(res);
wbeaumont 0:e71d3ecdd257 301 res= get_bits(reg,ALS_GAIN_LSB , ALS_GAIN_SIZE ) ;
wbeaumont 0:e71d3ecdd257 302 gain=decodeGainBits(res);
wbeaumont 0:e71d3ecdd257 303 }