Components / MPL3115A2

Llibrary for the WiGo MPL3115A2, I2C Precision Altimeter sensor. This is a temp fork

Dependents:   sensor AerCloud_MutliTech_Socket_Modem_Example Freescale_Multi-Sensor_Shield 2lemetry_Sensor_Example ... more

Fork of MPL3115A2 by clemente di caprio

MPL3115A2.cpp@7:59e9ba115d0a, 2013-08-25 (annotated)

Committer:
clemente
Date:
Sun Aug 25 21:48:05 2013 +0000
Revision:
7:59e9ba115d0a
Parent:
6:03c24251e500
Child:
8:89ed6aeb5dbb
changed the name of the pointer to user callback function.

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