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@5:9edec5ee8bf4, 2013-08-22 (annotated)

Committer:
clemente
Date:
Thu Aug 22 12:03:19 2013 +0000
Revision:
5:9edec5ee8bf4
Parent:
4:fdf14a259af8
Child:
6:03c24251e500
Added function to read raw data in polling mode. Minor change.

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