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@9:75a5960adf5c, 2013-09-22 (annotated)

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