JP PANG / MPL3115A2

Llibrary for the WiGo MPL3115A2, I2C Precision Altimeter sensor.

Dependents:   XtrinsicSensorEVK

Fork of MPL3115A2 by clemente di caprio

MPL3115A2.cpp@11:98b64b8fe817, 2013-10-10 (annotated)

Committer:
jppang
Date:
Thu Oct 10 02:21:36 2013 +0000
Revision:
11:98b64b8fe817
Parent:
10:82ac06669316 
modified interrupt pins bonding

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