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@8:89ed6aeb5dbb, 2013-09-22 (annotated)

Committer:
clemente
Date:
Sun Sep 22 07:04:14 2013 +0000
Revision:
8:89ed6aeb5dbb
Parent:
7:59e9ba115d0a
Child:
9:75a5960adf5c
Added functions to set offset for temperature, altitude and pressure, as De Cremer Tim suggest.

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