clemente di caprio / MPL3115A2

Llibrary for the WiGo MPL3115A2, I2C Precision Altimeter sensor.

Dependents:   KL25Z_Batt_Test WIGO_MPL3115A2 Multi-Sensor SPACEmk2 ... more

30/05/2013 Added and tested the data acquisition using Interrupt. Added code for Altimeter trigger Interrupt but not yet tested.

Very basic library. Under development. Need to add in order: 1. IRQ configuration. 2. FIFO mode configuration.

MPL3115A2.cpp@3:a2f1752add9a, 2013-05-29 (annotated)

Committer:
clemente
Date:
Wed May 29 11:56:52 2013 +0000
Revision:
3:a2f1752add9a
Parent:
2:a2fcfb7ff611
Child:
4:fdf14a259af8
Code for Altitude trigger and data ready using IRQ. To be tested.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
clemente 0:cfecfabc5e23 1 #include "MPL3115A2.h"
clemente 0:cfecfabc5e23 2
clemente 2:a2fcfb7ff611 3 #define REG_WHO_AM_I 0x0C // return 0xC4 by default
clemente 0:cfecfabc5e23 4 #define REG_STATUS 0x00
clemente 0:cfecfabc5e23 5 #define REG_CTRL_REG_1 0x26
clemente 2:a2fcfb7ff611 6 #define REG_CTRL_REG_4 0x29
clemente 2:a2fcfb7ff611 7 #define REG_CTRL_REG_5 0x2A
clemente 0:cfecfabc5e23 8 #define REG_PRESSURE_MSB 0x01 // 3 byte pressure data
clemente 0:cfecfabc5e23 9 #define REG_ALTIMETER_MSB 0x01 // 3 byte altimeter data
clemente 0:cfecfabc5e23 10 #define REG_TEMP_MSB 0x04 // 2 byte temperature data
clemente 0:cfecfabc5e23 11 #define REG_PT_DATA_CFG 0x13
clemente 3:a2f1752add9a 12 #define REG_P_TGT_MSB 0x16
clemente 3:a2f1752add9a 13 #define REG_P_WND_MSB 0x19
clemente 0:cfecfabc5e23 14
clemente 0:cfecfabc5e23 15 #define UINT14_MAX 16383
clemente 0:cfecfabc5e23 16
clemente 3:a2f1752add9a 17 /** Interrupt schema
clemente 3:a2f1752add9a 18 *
clemente 3:a2f1752add9a 19 * :: The Altitude Trigger use the IRQ1.
clemente 3:a2f1752add9a 20 *
clemente 3:a2f1752add9a 21 * Altitude Trigger -- MPL3115A2_Int1.fall --- AltitudeTrg_IRQ --- user1_fptr
clemente 3:a2f1752add9a 22 *
clemente 3:a2f1752add9a 23 *
clemente 3:a2f1752add9a 24 * :: The Data ready use the IRQ2.
clemente 3:a2f1752add9a 25 *
clemente 3:a2f1752add9a 26 * Data Ready -- MPL3115A2_Int2.fall --- DataReady_IRQ --- user2_fptr
clemente 3:a2f1752add9a 27 *
clemente 3:a2f1752add9a 28 */
clemente 2:a2fcfb7ff611 29 void (*user2_fptr)(void); // Pointers to user function called after
clemente 2:a2fcfb7ff611 30 void (*user1_fptr)(void); // IRQ assertion.
clemente 2:a2fcfb7ff611 31
clemente 2:a2fcfb7ff611 32 //
clemente 2:a2fcfb7ff611 33 InterruptIn MPL3115A2_Int1( PTD4); // INT1
clemente 2:a2fcfb7ff611 34 InterruptIn MPL3115A2_Int2( PTA12); // INT2
clemente 2:a2fcfb7ff611 35
clemente 0:cfecfabc5e23 36 MPL3115A2::MPL3115A2(PinName sda, PinName scl, int addr) : m_i2c(sda, scl), m_addr(addr) {
clemente 0:cfecfabc5e23 37 MPL3115A2_mode = BAROMETRIC_MODE;
clemente 0:cfecfabc5e23 38 MPL3115A2_oversampling = OVERSAMPLE_RATIO_1;
clemente 0:cfecfabc5e23 39 }
clemente 0:cfecfabc5e23 40
clemente 2:a2fcfb7ff611 41 void MPL3115A2::Reset( void)
clemente 2:a2fcfb7ff611 42 {
clemente 2:a2fcfb7ff611 43 unsigned char t;
clemente 2:a2fcfb7ff611 44
clemente 2:a2fcfb7ff611 45 // soft reset...
clemente 2:a2fcfb7ff611 46 readRegs( REG_CTRL_REG_1, &t, 1);
clemente 2:a2fcfb7ff611 47 unsigned char data[2] = { REG_CTRL_REG_1, t|0x04};
clemente 2:a2fcfb7ff611 48 writeRegs(data, 2);
clemente 2:a2fcfb7ff611 49 wait( 0.1);
clemente 2:a2fcfb7ff611 50
clemente 2:a2fcfb7ff611 51 }
clemente 2:a2fcfb7ff611 52
clemente 2:a2fcfb7ff611 53 void MPL3115A2::DataReady( void(*fptr)(void), unsigned char OS)
clemente 2:a2fcfb7ff611 54 {
clemente 2:a2fcfb7ff611 55 unsigned char dt[5];
clemente 2:a2fcfb7ff611 56 unsigned char data[2];
clemente 2:a2fcfb7ff611 57
clemente 2:a2fcfb7ff611 58 Reset();
clemente 2:a2fcfb7ff611 59
clemente 2:a2fcfb7ff611 60 /*
clemente 2:a2fcfb7ff611 61 ** Read contents of CTRL_REG_1
clemente 2:a2fcfb7ff611 62 ** Clear SBYB mask while holding all other values of CTRL_REG_1.
clemente 2:a2fcfb7ff611 63 ** To put part into Standby mode
clemente 2:a2fcfb7ff611 64 */
clemente 2:a2fcfb7ff611 65 Standby();
clemente 2:a2fcfb7ff611 66
clemente 2:a2fcfb7ff611 67 /*
clemente 2:a2fcfb7ff611 68 ** Clear all interrupts by reading the output registers.
clemente 2:a2fcfb7ff611 69 ** Activate sensor in Altimeter mode.
clemente 2:a2fcfb7ff611 70 */
clemente 2:a2fcfb7ff611 71 readRegs( REG_ALTIMETER_MSB, &dt[0], 5);
clemente 2:a2fcfb7ff611 72 getStatus();
clemente 2:a2fcfb7ff611 73 // Enable Interrupt fot data ready
clemente 2:a2fcfb7ff611 74 data[0] = REG_CTRL_REG_4;
clemente 2:a2fcfb7ff611 75 data[1] = 0x80;
clemente 2:a2fcfb7ff611 76 writeRegs(data, 2);
clemente 3:a2f1752add9a 77 // Configure Interrupt to route to INT2
clemente 2:a2fcfb7ff611 78 data[0] = REG_CTRL_REG_5;
clemente 2:a2fcfb7ff611 79 data[1] = 0x00;
clemente 2:a2fcfb7ff611 80 writeRegs(data, 2);
clemente 2:a2fcfb7ff611 81
clemente 2:a2fcfb7ff611 82 /*
clemente 3:a2f1752add9a 83 ** Configure the OverSampling rate, Altimeter mode and set the sensor Active
clemente 2:a2fcfb7ff611 84 */
clemente 2:a2fcfb7ff611 85 data[0] = REG_CTRL_REG_1;
clemente 2:a2fcfb7ff611 86 data[1] = 0x81 | (OS<<3);
clemente 2:a2fcfb7ff611 87 writeRegs(data, 2);
clemente 2:a2fcfb7ff611 88
clemente 2:a2fcfb7ff611 89 user2_fptr = fptr;
clemente 2:a2fcfb7ff611 90 MPL3115A2_Int2.fall( this, &MPL3115A2::DataReady_IRQ);
clemente 2:a2fcfb7ff611 91
clemente 2:a2fcfb7ff611 92 }
clemente 2:a2fcfb7ff611 93
clemente 2:a2fcfb7ff611 94 void MPL3115A2::DataReady_IRQ( void)
clemente 2:a2fcfb7ff611 95 {
clemente 2:a2fcfb7ff611 96 // Clear the IRQ flag
clemente 2:a2fcfb7ff611 97 getStatus();
clemente 2:a2fcfb7ff611 98 // Run the user supplied function
clemente 2:a2fcfb7ff611 99 user2_fptr();
clemente 2:a2fcfb7ff611 100 }
clemente 2:a2fcfb7ff611 101
clemente 3:a2f1752add9a 102 void MPL3115A2::AltitudeTrigger( void(*fptr)(void), unsigned short level)
clemente 3:a2f1752add9a 103 {
clemente 3:a2f1752add9a 104 unsigned char dt[5];
clemente 3:a2f1752add9a 105 unsigned char data[2];
clemente 3:a2f1752add9a 106
clemente 3:a2f1752add9a 107 // Soft Reset
clemente 3:a2f1752add9a 108 Reset();
clemente 3:a2f1752add9a 109
clemente 3:a2f1752add9a 110 // The device is on standby
clemente 3:a2f1752add9a 111 Standby();
clemente 3:a2f1752add9a 112
clemente 3:a2f1752add9a 113 // Clear all interrupts by reading the output registers.
clemente 3:a2f1752add9a 114 readRegs( REG_ALTIMETER_MSB, &dt[0], 5);
clemente 3:a2f1752add9a 115 getStatus();
clemente 3:a2f1752add9a 116
clemente 3:a2f1752add9a 117 // Write Target and Window Values
clemente 3:a2f1752add9a 118 data[0] = (level<<8);
clemente 3:a2f1752add9a 119 data[1] = (level&0xFF);
clemente 3:a2f1752add9a 120 writeRegs( data, 2);
clemente 3:a2f1752add9a 121
clemente 3:a2f1752add9a 122 // Window values are zero
clemente 3:a2f1752add9a 123 data[0] = 0;
clemente 3:a2f1752add9a 124 data[1] = 0;
clemente 3:a2f1752add9a 125 writeRegs( data, 2);
clemente 3:a2f1752add9a 126
clemente 3:a2f1752add9a 127 // Enable Pressure Threshold interrupt
clemente 3:a2f1752add9a 128 data[0] = REG_CTRL_REG_4;
clemente 3:a2f1752add9a 129 data[1] = 0x08;
clemente 3:a2f1752add9a 130 writeRegs( data, 2);
clemente 3:a2f1752add9a 131 // Interrupt is routed to INT1
clemente 3:a2f1752add9a 132 data[0] = REG_CTRL_REG_5;
clemente 3:a2f1752add9a 133 data[1] = 0x08;
clemente 3:a2f1752add9a 134 writeRegs( data, 2);
clemente 3:a2f1752add9a 135
clemente 3:a2f1752add9a 136 Active();
clemente 3:a2f1752add9a 137
clemente 3:a2f1752add9a 138 user1_fptr = fptr;
clemente 3:a2f1752add9a 139 MPL3115A2_Int1.fall( this, &MPL3115A2::AltitudeTrg_IRQ);
clemente 3:a2f1752add9a 140
clemente 3:a2f1752add9a 141 }
clemente 3:a2f1752add9a 142
clemente 3:a2f1752add9a 143 void MPL3115A2::AltitudeTrg_IRQ( void)
clemente 3:a2f1752add9a 144 {
clemente 3:a2f1752add9a 145 // Clear the IRQ flag
clemente 3:a2f1752add9a 146 getStatus();
clemente 3:a2f1752add9a 147 // Run the user supplied function
clemente 3:a2f1752add9a 148 user1_fptr();
clemente 3:a2f1752add9a 149
clemente 3:a2f1752add9a 150 }
clemente 3:a2f1752add9a 151
clemente 0:cfecfabc5e23 152 void MPL3115A2::Barometric_Mode( void)
clemente 0:cfecfabc5e23 153 {
clemente 0:cfecfabc5e23 154 unsigned char t;
clemente 2:a2fcfb7ff611 155 unsigned char data[2];
clemente 0:cfecfabc5e23 156
clemente 0:cfecfabc5e23 157 Standby();
clemente 0:cfecfabc5e23 158
clemente 0:cfecfabc5e23 159 // soft reset...
clemente 2:a2fcfb7ff611 160 Reset();
clemente 2:a2fcfb7ff611 161
clemente 0:cfecfabc5e23 162 Standby();
clemente 0:cfecfabc5e23 163 readRegs( REG_CTRL_REG_1, &t, 1);
clemente 0:cfecfabc5e23 164
clemente 2:a2fcfb7ff611 165 // Set the Barometric mode
clemente 0:cfecfabc5e23 166 data[0] = REG_CTRL_REG_1;
clemente 0:cfecfabc5e23 167 data[1] = t&0x7F;
clemente 0:cfecfabc5e23 168 writeRegs(data, 2);
clemente 0:cfecfabc5e23 169
clemente 0:cfecfabc5e23 170 data[0] = REG_PT_DATA_CFG;
clemente 0:cfecfabc5e23 171 data[1] = 0x07;
clemente 0:cfecfabc5e23 172 writeRegs(data, 2);
clemente 0:cfecfabc5e23 173
clemente 0:cfecfabc5e23 174 Oversample_Ratio( MPL3115A2_oversampling);
clemente 0:cfecfabc5e23 175
clemente 0:cfecfabc5e23 176 Active();
clemente 0:cfecfabc5e23 177
clemente 0:cfecfabc5e23 178 MPL3115A2_mode = BAROMETRIC_MODE;
clemente 0:cfecfabc5e23 179 }
clemente 0:cfecfabc5e23 180
clemente 0:cfecfabc5e23 181 void MPL3115A2::Altimeter_Mode( void)
clemente 0:cfecfabc5e23 182 {
clemente 0:cfecfabc5e23 183 unsigned char t;
clemente 2:a2fcfb7ff611 184 unsigned char data[2];
clemente 2:a2fcfb7ff611 185
clemente 0:cfecfabc5e23 186 Standby();
clemente 0:cfecfabc5e23 187
clemente 0:cfecfabc5e23 188 // soft reset...
clemente 2:a2fcfb7ff611 189 Reset();
clemente 0:cfecfabc5e23 190
clemente 0:cfecfabc5e23 191 Standby();
clemente 0:cfecfabc5e23 192 readRegs( REG_CTRL_REG_1, &t, 1);
clemente 0:cfecfabc5e23 193
clemente 0:cfecfabc5e23 194 data[0] = REG_CTRL_REG_1;
clemente 0:cfecfabc5e23 195 data[1] = t|0x80;
clemente 0:cfecfabc5e23 196 writeRegs(data, 2);
clemente 0:cfecfabc5e23 197
clemente 0:cfecfabc5e23 198 data[0] = REG_PT_DATA_CFG;
clemente 0:cfecfabc5e23 199 data[1] = 0x07;
clemente 0:cfecfabc5e23 200 writeRegs(data, 2);
clemente 0:cfecfabc5e23 201
clemente 0:cfecfabc5e23 202 Oversample_Ratio( MPL3115A2_oversampling);
clemente 0:cfecfabc5e23 203
clemente 0:cfecfabc5e23 204 Active();
clemente 0:cfecfabc5e23 205
clemente 0:cfecfabc5e23 206 MPL3115A2_mode = ALTIMETER_MODE;
clemente 0:cfecfabc5e23 207 }
clemente 0:cfecfabc5e23 208
clemente 0:cfecfabc5e23 209 void MPL3115A2::Oversample_Ratio( unsigned int ratio)
clemente 0:cfecfabc5e23 210 {
clemente 0:cfecfabc5e23 211 unsigned char t;
clemente 0:cfecfabc5e23 212
clemente 0:cfecfabc5e23 213 Standby();
clemente 0:cfecfabc5e23 214 readRegs( REG_CTRL_REG_1, &t, 1);
clemente 0:cfecfabc5e23 215
clemente 0:cfecfabc5e23 216 t = t & 0xE7;
clemente 0:cfecfabc5e23 217 t = t | ( ratio<<3);
clemente 0:cfecfabc5e23 218
clemente 0:cfecfabc5e23 219 unsigned char data[2] = { REG_CTRL_REG_1, t};
clemente 0:cfecfabc5e23 220 writeRegs(data, 2);
clemente 0:cfecfabc5e23 221
clemente 0:cfecfabc5e23 222 Active();
clemente 0:cfecfabc5e23 223
clemente 0:cfecfabc5e23 224 MPL3115A2_oversampling = ratio;
clemente 0:cfecfabc5e23 225 }
clemente 0:cfecfabc5e23 226
clemente 0:cfecfabc5e23 227
clemente 0:cfecfabc5e23 228 void MPL3115A2::Active( void)
clemente 0:cfecfabc5e23 229 {
clemente 0:cfecfabc5e23 230 unsigned char t;
clemente 0:cfecfabc5e23 231
clemente 0:cfecfabc5e23 232 // Activate the peripheral
clemente 0:cfecfabc5e23 233 readRegs(REG_CTRL_REG_1, &t, 1);
clemente 0:cfecfabc5e23 234 unsigned char data[2] = {REG_CTRL_REG_1, t|0x01};
clemente 0:cfecfabc5e23 235 writeRegs(data, 2);
clemente 0:cfecfabc5e23 236 }
clemente 0:cfecfabc5e23 237
clemente 0:cfecfabc5e23 238 void MPL3115A2::Standby( void)
clemente 0:cfecfabc5e23 239 {
clemente 0:cfecfabc5e23 240 unsigned char t;
clemente 0:cfecfabc5e23 241
clemente 0:cfecfabc5e23 242 // Standby
clemente 0:cfecfabc5e23 243 readRegs(REG_CTRL_REG_1, &t, 1);
clemente 0:cfecfabc5e23 244 unsigned char data[2] = {REG_CTRL_REG_1, t&0xFE};
clemente 0:cfecfabc5e23 245 writeRegs(data, 2);
clemente 0:cfecfabc5e23 246 }
clemente 0:cfecfabc5e23 247
clemente 0:cfecfabc5e23 248 unsigned char MPL3115A2::getDeviceID() {
clemente 0:cfecfabc5e23 249 unsigned char device_id = 0;
clemente 0:cfecfabc5e23 250 readRegs(REG_WHO_AM_I, &device_id, 1);
clemente 0:cfecfabc5e23 251 return device_id;
clemente 0:cfecfabc5e23 252 }
clemente 0:cfecfabc5e23 253
clemente 0:cfecfabc5e23 254 unsigned int MPL3115A2::isDataAvailable( void)
clemente 0:cfecfabc5e23 255 {
clemente 0:cfecfabc5e23 256 unsigned char status;
clemente 0:cfecfabc5e23 257
clemente 0:cfecfabc5e23 258 readRegs( REG_STATUS, &status, 1);
clemente 0:cfecfabc5e23 259
clemente 0:cfecfabc5e23 260 if ( status & 0x08) {
clemente 0:cfecfabc5e23 261 return 1;
clemente 0:cfecfabc5e23 262 } else {
clemente 0:cfecfabc5e23 263 return 0;
clemente 0:cfecfabc5e23 264 }
clemente 0:cfecfabc5e23 265
clemente 0:cfecfabc5e23 266 }
clemente 0:cfecfabc5e23 267
clemente 0:cfecfabc5e23 268 unsigned char MPL3115A2::getStatus( void)
clemente 0:cfecfabc5e23 269 {
clemente 0:cfecfabc5e23 270 unsigned char status;
clemente 0:cfecfabc5e23 271
clemente 0:cfecfabc5e23 272 readRegs( REG_STATUS, &status, 1);
clemente 0:cfecfabc5e23 273 return status;
clemente 0:cfecfabc5e23 274 }
clemente 0:cfecfabc5e23 275
clemente 0:cfecfabc5e23 276 void MPL3115A2::getAllData( float *f)
clemente 0:cfecfabc5e23 277 {
clemente 0:cfecfabc5e23 278 if ( MPL3115A2_mode == ALTIMETER_MODE) {
clemente 0:cfecfabc5e23 279 f[0] = getAltimeter();
clemente 0:cfecfabc5e23 280 } else {
clemente 0:cfecfabc5e23 281 f[0] = getPressure();
clemente 0:cfecfabc5e23 282 }
clemente 0:cfecfabc5e23 283
clemente 0:cfecfabc5e23 284 f[1] = getTemperature();
clemente 0:cfecfabc5e23 285 }
clemente 0:cfecfabc5e23 286
clemente 0:cfecfabc5e23 287 float MPL3115A2::getAltimeter( void)
clemente 0:cfecfabc5e23 288 {
clemente 0:cfecfabc5e23 289 unsigned char dt[3];
clemente 0:cfecfabc5e23 290 unsigned short altm;
clemente 0:cfecfabc5e23 291 float faltm;
clemente 0:cfecfabc5e23 292
clemente 0:cfecfabc5e23 293 /*
clemente 0:cfecfabc5e23 294 * dt[0] = Bits 12-19 of 20-bit real-time Pressure sample. (b7-b0)
clemente 0:cfecfabc5e23 295 * dt[1] = Bits 4-11 of 20-bit real-time Pressure sample. (b7-b0)
clemente 0:cfecfabc5e23 296 * dt[2] = Bits 0-3 of 20-bit real-time Pressure sample (b7-b4)
clemente 0:cfecfabc5e23 297 */
clemente 0:cfecfabc5e23 298 readRegs( REG_ALTIMETER_MSB, &dt[0], 3);
clemente 0:cfecfabc5e23 299 altm = (dt[0]<<8) | dt[1];
clemente 0:cfecfabc5e23 300 //
clemente 0:cfecfabc5e23 301 if ( dt[0] > 0x7F) {
clemente 0:cfecfabc5e23 302 altm = ~altm + 1;
clemente 0:cfecfabc5e23 303 faltm = (float)altm * -1.0f;
clemente 0:cfecfabc5e23 304 } else {
clemente 0:cfecfabc5e23 305 faltm = (float)altm * 1.0f;
clemente 0:cfecfabc5e23 306 }
clemente 0:cfecfabc5e23 307 //
clemente 0:cfecfabc5e23 308 faltm = faltm+((float)(dt[2]>>4) * 0.0625f);
clemente 0:cfecfabc5e23 309 return faltm;
clemente 0:cfecfabc5e23 310 }
clemente 0:cfecfabc5e23 311
clemente 0:cfecfabc5e23 312 float MPL3115A2::getPressure( void)
clemente 0:cfecfabc5e23 313 {
clemente 0:cfecfabc5e23 314 unsigned char dt[3];
clemente 0:cfecfabc5e23 315 unsigned int prs;
clemente 0:cfecfabc5e23 316 float fprs;
clemente 0:cfecfabc5e23 317
clemente 0:cfecfabc5e23 318 /*
clemente 0:cfecfabc5e23 319 * dt[0] = Bits 12-19 of 20-bit real-time Pressure sample. (b7-b0)
clemente 0:cfecfabc5e23 320 * dt[1] = Bits 4-11 of 20-bit real-time Pressure sample. (b7-b0)
clemente 0:cfecfabc5e23 321 * dt[2] = Bits 0-3 of 20-bit real-time Pressure sample (b7-b4)
clemente 0:cfecfabc5e23 322 */
clemente 0:cfecfabc5e23 323 readRegs( REG_PRESSURE_MSB, &dt[0], 3);
clemente 0:cfecfabc5e23 324 prs = (dt[0]<<10) | (dt[1]<<2) | (dt[2]>>6);
clemente 0:cfecfabc5e23 325 //
clemente 0:cfecfabc5e23 326 fprs = (float)prs * 1.0f;
clemente 0:cfecfabc5e23 327
clemente 0:cfecfabc5e23 328 if ( dt[2] & 0x20)
clemente 0:cfecfabc5e23 329 fprs += 0.25f;
clemente 0:cfecfabc5e23 330 if ( dt[2] & 0x10)
clemente 0:cfecfabc5e23 331 fprs += 0.5f;
clemente 0:cfecfabc5e23 332
clemente 0:cfecfabc5e23 333 return fprs;
clemente 0:cfecfabc5e23 334 }
clemente 0:cfecfabc5e23 335
clemente 0:cfecfabc5e23 336
clemente 0:cfecfabc5e23 337 float MPL3115A2::getTemperature( void)
clemente 0:cfecfabc5e23 338 {
clemente 0:cfecfabc5e23 339 unsigned char dt[2];
clemente 0:cfecfabc5e23 340 unsigned short temp;
clemente 0:cfecfabc5e23 341 float ftemp;
clemente 0:cfecfabc5e23 342
clemente 0:cfecfabc5e23 343 /*
clemente 0:cfecfabc5e23 344 * dt[0] = Bits 4-11 of 16-bit real-time temperature sample. (b7-b0)
clemente 0:cfecfabc5e23 345 * dt[1] = Bits 0-3 of 16-bit real-time temperature sample. (b7-b4)
clemente 0:cfecfabc5e23 346 */
clemente 0:cfecfabc5e23 347 readRegs( REG_TEMP_MSB, &dt[0], 2);
clemente 0:cfecfabc5e23 348 temp = dt[0];
clemente 0:cfecfabc5e23 349 //
clemente 0:cfecfabc5e23 350 if ( dt[0] > 0x7F) {
clemente 0:cfecfabc5e23 351 temp = ~temp + 1;
clemente 0:cfecfabc5e23 352 ftemp = (float)temp * -1.0f;
clemente 0:cfecfabc5e23 353 } else {
clemente 0:cfecfabc5e23 354 ftemp = (float)temp * 1.0f;
clemente 0:cfecfabc5e23 355 }
clemente 0:cfecfabc5e23 356 //
clemente 0:cfecfabc5e23 357 ftemp = ftemp+((float)(dt[1]>>4) * 0.0625f);
clemente 0:cfecfabc5e23 358 return ftemp;
clemente 0:cfecfabc5e23 359
clemente 0:cfecfabc5e23 360 }
clemente 0:cfecfabc5e23 361
clemente 0:cfecfabc5e23 362 void MPL3115A2::readRegs(int addr, uint8_t * data, int len) {
clemente 0:cfecfabc5e23 363 char t[1] = {addr};
clemente 0:cfecfabc5e23 364 m_i2c.write(m_addr, t, 1, true);
clemente 0:cfecfabc5e23 365 m_i2c.read(m_addr, (char *)data, len);
clemente 0:cfecfabc5e23 366 }
clemente 0:cfecfabc5e23 367
clemente 0:cfecfabc5e23 368 void MPL3115A2::writeRegs(uint8_t * data, int len) {
clemente 0:cfecfabc5e23 369 m_i2c.write(m_addr, (char *)data, len);
clemente 0:cfecfabc5e23 370 }