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@11:8c90a97b1036, 2014-07-25 (annotated)

Committer:
screamer
Date:
Fri Jul 25 11:34:09 2014 +0000
Revision:
11:8c90a97b1036
Parent:
10:82ac06669316 
Change the constructor to accept Int1 and Int2 interrupts as params and removed dependency on Freescale specific pin naming

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