long dao / MPL3115A2

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

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 }