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@4:fdf14a259af8, 2013-05-30 (annotated)

Committer:
clemente
Date:
Thu May 30 07:27:24 2013 +0000
Revision:
4:fdf14a259af8
Parent:
3:a2f1752add9a
Child:
5:9edec5ee8bf4
Added and tested the data acquisition using Interrupt. Added code for Altimeter trigger Interrupt but not yet tested.

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 3:a2f1752add9a 18 /** Interrupt schema
clemente 3:a2f1752add9a 19 *
clemente 3:a2f1752add9a 20 * :: The Altitude Trigger use the IRQ1.
clemente 3:a2f1752add9a 21 *
clemente 3:a2f1752add9a 22 * Altitude Trigger -- MPL3115A2_Int1.fall --- AltitudeTrg_IRQ --- user1_fptr
clemente 3:a2f1752add9a 23 *
clemente 3:a2f1752add9a 24 *
clemente 3:a2f1752add9a 25 * :: The Data ready use the IRQ2.
clemente 3:a2f1752add9a 26 *
clemente 3:a2f1752add9a 27 * Data Ready -- MPL3115A2_Int2.fall --- DataReady_IRQ --- user2_fptr
clemente 3:a2f1752add9a 28 *
clemente 3:a2f1752add9a 29 */
clemente 2:a2fcfb7ff611 30 void (*user2_fptr)(void); // Pointers to user function called after
clemente 2:a2fcfb7ff611 31 void (*user1_fptr)(void); // IRQ assertion.
clemente 2:a2fcfb7ff611 32
clemente 2:a2fcfb7ff611 33 //
clemente 2:a2fcfb7ff611 34 InterruptIn MPL3115A2_Int1( PTD4); // INT1
clemente 2:a2fcfb7ff611 35 InterruptIn MPL3115A2_Int2( PTA12); // INT2
clemente 2:a2fcfb7ff611 36
clemente 0:cfecfabc5e23 37 MPL3115A2::MPL3115A2(PinName sda, PinName scl, int addr) : m_i2c(sda, scl), m_addr(addr) {
clemente 0:cfecfabc5e23 38 MPL3115A2_mode = BAROMETRIC_MODE;
clemente 0:cfecfabc5e23 39 MPL3115A2_oversampling = OVERSAMPLE_RATIO_1;
clemente 4:fdf14a259af8 40 //
clemente 4:fdf14a259af8 41 user1_fptr = NULL;
clemente 4:fdf14a259af8 42 user2_fptr = NULL;
clemente 4:fdf14a259af8 43 MPL3115A2_Int1.fall( NULL);
clemente 4:fdf14a259af8 44 MPL3115A2_Int2.fall( NULL);
clemente 0:cfecfabc5e23 45 }
clemente 0:cfecfabc5e23 46
clemente 2:a2fcfb7ff611 47 void MPL3115A2::Reset( void)
clemente 2:a2fcfb7ff611 48 {
clemente 2:a2fcfb7ff611 49 unsigned char t;
clemente 2:a2fcfb7ff611 50
clemente 2:a2fcfb7ff611 51 // soft reset...
clemente 2:a2fcfb7ff611 52 readRegs( REG_CTRL_REG_1, &t, 1);
clemente 2:a2fcfb7ff611 53 unsigned char data[2] = { REG_CTRL_REG_1, t|0x04};
clemente 2:a2fcfb7ff611 54 writeRegs(data, 2);
clemente 2:a2fcfb7ff611 55 wait( 0.1);
clemente 2:a2fcfb7ff611 56
clemente 2:a2fcfb7ff611 57 }
clemente 2:a2fcfb7ff611 58
clemente 2:a2fcfb7ff611 59 void MPL3115A2::DataReady( void(*fptr)(void), unsigned char OS)
clemente 2:a2fcfb7ff611 60 {
clemente 2:a2fcfb7ff611 61 unsigned char dt[5];
clemente 2:a2fcfb7ff611 62 unsigned char data[2];
clemente 2:a2fcfb7ff611 63
clemente 4:fdf14a259af8 64 // Soft Reset
clemente 2:a2fcfb7ff611 65 Reset();
clemente 2:a2fcfb7ff611 66
clemente 2:a2fcfb7ff611 67 Standby();
clemente 2:a2fcfb7ff611 68
clemente 4:fdf14a259af8 69 // Clear all interrupts by reading the output registers.
clemente 2:a2fcfb7ff611 70 readRegs( REG_ALTIMETER_MSB, &dt[0], 5);
clemente 2:a2fcfb7ff611 71 getStatus();
clemente 4:fdf14a259af8 72 // Configure INT active low and pullup
clemente 4:fdf14a259af8 73 data[0] = REG_CTRL_REG_3;
clemente 4:fdf14a259af8 74 data[1] = 0x00;
clemente 4:fdf14a259af8 75 writeRegs(data, 2);
clemente 2:a2fcfb7ff611 76 // Enable Interrupt fot data ready
clemente 2:a2fcfb7ff611 77 data[0] = REG_CTRL_REG_4;
clemente 2:a2fcfb7ff611 78 data[1] = 0x80;
clemente 2:a2fcfb7ff611 79 writeRegs(data, 2);
clemente 3:a2f1752add9a 80 // Configure Interrupt to route to INT2
clemente 2:a2fcfb7ff611 81 data[0] = REG_CTRL_REG_5;
clemente 2:a2fcfb7ff611 82 data[1] = 0x00;
clemente 2:a2fcfb7ff611 83 writeRegs(data, 2);
clemente 4:fdf14a259af8 84 data[0] = REG_PT_DATA_CFG;
clemente 4:fdf14a259af8 85 data[1] = 0x07;
clemente 4:fdf14a259af8 86 writeRegs(data, 2);
clemente 2:a2fcfb7ff611 87
clemente 4:fdf14a259af8 88 // Configure the OverSampling rate, Altimeter/Barometer mode and set the sensor Active
clemente 2:a2fcfb7ff611 89 data[0] = REG_CTRL_REG_1;
clemente 4:fdf14a259af8 90 data[1] = (OS<<3);
clemente 4:fdf14a259af8 91 //
clemente 4:fdf14a259af8 92 if (MPL3115A2_mode == BAROMETRIC_MODE)
clemente 4:fdf14a259af8 93 data[1] &= 0x7F;
clemente 4:fdf14a259af8 94 else
clemente 4:fdf14a259af8 95 data[1] |= 0x80;
clemente 4:fdf14a259af8 96 //
clemente 4:fdf14a259af8 97 data[1] |= 0x01;
clemente 2:a2fcfb7ff611 98 writeRegs(data, 2);
clemente 2:a2fcfb7ff611 99
clemente 2:a2fcfb7ff611 100 user2_fptr = fptr;
clemente 2:a2fcfb7ff611 101 MPL3115A2_Int2.fall( this, &MPL3115A2::DataReady_IRQ);
clemente 2:a2fcfb7ff611 102
clemente 2:a2fcfb7ff611 103 }
clemente 2:a2fcfb7ff611 104
clemente 2:a2fcfb7ff611 105 void MPL3115A2::DataReady_IRQ( void)
clemente 2:a2fcfb7ff611 106 {
clemente 2:a2fcfb7ff611 107 // Clear the IRQ flag
clemente 2:a2fcfb7ff611 108 getStatus();
clemente 2:a2fcfb7ff611 109 // Run the user supplied function
clemente 2:a2fcfb7ff611 110 user2_fptr();
clemente 2:a2fcfb7ff611 111 }
clemente 2:a2fcfb7ff611 112
clemente 3:a2f1752add9a 113 void MPL3115A2::AltitudeTrigger( void(*fptr)(void), unsigned short level)
clemente 3:a2f1752add9a 114 {
clemente 3:a2f1752add9a 115 unsigned char dt[5];
clemente 3:a2f1752add9a 116 unsigned char data[2];
clemente 3:a2f1752add9a 117
clemente 3:a2f1752add9a 118 // Soft Reset
clemente 3:a2f1752add9a 119 Reset();
clemente 3:a2f1752add9a 120
clemente 3:a2f1752add9a 121 // The device is on standby
clemente 3:a2f1752add9a 122 Standby();
clemente 3:a2f1752add9a 123
clemente 3:a2f1752add9a 124 // Clear all interrupts by reading the output registers.
clemente 3:a2f1752add9a 125 readRegs( REG_ALTIMETER_MSB, &dt[0], 5);
clemente 3:a2f1752add9a 126 getStatus();
clemente 3:a2f1752add9a 127
clemente 3:a2f1752add9a 128 // Write Target and Window Values
clemente 4:fdf14a259af8 129 dt[0] = REG_P_TGT_MSB;
clemente 4:fdf14a259af8 130 dt[1] = (level>>8);
clemente 4:fdf14a259af8 131 dt[2] = (level&0xFF);
clemente 4:fdf14a259af8 132 writeRegs( dt, 3);
clemente 3:a2f1752add9a 133
clemente 3:a2f1752add9a 134 // Window values are zero
clemente 4:fdf14a259af8 135 dt[0] = REG_P_WND_MSB;
clemente 4:fdf14a259af8 136 dt[1] = 0;
clemente 4:fdf14a259af8 137 dt[2] = 0;
clemente 4:fdf14a259af8 138 writeRegs( dt, 3);
clemente 3:a2f1752add9a 139
clemente 3:a2f1752add9a 140 // Enable Pressure Threshold interrupt
clemente 3:a2f1752add9a 141 data[0] = REG_CTRL_REG_4;
clemente 3:a2f1752add9a 142 data[1] = 0x08;
clemente 3:a2f1752add9a 143 writeRegs( data, 2);
clemente 3:a2f1752add9a 144 // Interrupt is routed to INT1
clemente 3:a2f1752add9a 145 data[0] = REG_CTRL_REG_5;
clemente 3:a2f1752add9a 146 data[1] = 0x08;
clemente 3:a2f1752add9a 147 writeRegs( data, 2);
clemente 4:fdf14a259af8 148 data[0] = REG_PT_DATA_CFG;
clemente 4:fdf14a259af8 149 data[1] = 0x07;
clemente 4:fdf14a259af8 150 writeRegs(data, 2);
clemente 4:fdf14a259af8 151 // Configure the OverSampling rate, Altimeter mode and set the sensor Active
clemente 4:fdf14a259af8 152 data[0] = REG_CTRL_REG_1;
clemente 4:fdf14a259af8 153 data[1] = 0x81 | (MPL3115A2_oversampling<<3);
clemente 4:fdf14a259af8 154 writeRegs(data, 2);
clemente 3:a2f1752add9a 155
clemente 3:a2f1752add9a 156 user1_fptr = fptr;
clemente 3:a2f1752add9a 157 MPL3115A2_Int1.fall( this, &MPL3115A2::AltitudeTrg_IRQ);
clemente 3:a2f1752add9a 158
clemente 3:a2f1752add9a 159 }
clemente 3:a2f1752add9a 160
clemente 3:a2f1752add9a 161 void MPL3115A2::AltitudeTrg_IRQ( void)
clemente 3:a2f1752add9a 162 {
clemente 3:a2f1752add9a 163 // Clear the IRQ flag
clemente 3:a2f1752add9a 164 getStatus();
clemente 3:a2f1752add9a 165 // Run the user supplied function
clemente 3:a2f1752add9a 166 user1_fptr();
clemente 3:a2f1752add9a 167
clemente 3:a2f1752add9a 168 }
clemente 3:a2f1752add9a 169
clemente 0:cfecfabc5e23 170 void MPL3115A2::Barometric_Mode( void)
clemente 0:cfecfabc5e23 171 {
clemente 0:cfecfabc5e23 172 unsigned char t;
clemente 2:a2fcfb7ff611 173 unsigned char data[2];
clemente 0:cfecfabc5e23 174
clemente 0:cfecfabc5e23 175 Standby();
clemente 0:cfecfabc5e23 176
clemente 0:cfecfabc5e23 177 // soft reset...
clemente 2:a2fcfb7ff611 178 Reset();
clemente 2:a2fcfb7ff611 179
clemente 0:cfecfabc5e23 180 Standby();
clemente 0:cfecfabc5e23 181 readRegs( REG_CTRL_REG_1, &t, 1);
clemente 0:cfecfabc5e23 182
clemente 2:a2fcfb7ff611 183 // Set the Barometric mode
clemente 0:cfecfabc5e23 184 data[0] = REG_CTRL_REG_1;
clemente 0:cfecfabc5e23 185 data[1] = t&0x7F;
clemente 0:cfecfabc5e23 186 writeRegs(data, 2);
clemente 0:cfecfabc5e23 187
clemente 0:cfecfabc5e23 188 data[0] = REG_PT_DATA_CFG;
clemente 0:cfecfabc5e23 189 data[1] = 0x07;
clemente 0:cfecfabc5e23 190 writeRegs(data, 2);
clemente 0:cfecfabc5e23 191
clemente 0:cfecfabc5e23 192 Oversample_Ratio( MPL3115A2_oversampling);
clemente 0:cfecfabc5e23 193
clemente 0:cfecfabc5e23 194 Active();
clemente 0:cfecfabc5e23 195
clemente 0:cfecfabc5e23 196 MPL3115A2_mode = BAROMETRIC_MODE;
clemente 0:cfecfabc5e23 197 }
clemente 0:cfecfabc5e23 198
clemente 0:cfecfabc5e23 199 void MPL3115A2::Altimeter_Mode( void)
clemente 0:cfecfabc5e23 200 {
clemente 0:cfecfabc5e23 201 unsigned char t;
clemente 2:a2fcfb7ff611 202 unsigned char data[2];
clemente 2:a2fcfb7ff611 203
clemente 0:cfecfabc5e23 204 Standby();
clemente 0:cfecfabc5e23 205
clemente 0:cfecfabc5e23 206 // soft reset...
clemente 2:a2fcfb7ff611 207 Reset();
clemente 0:cfecfabc5e23 208
clemente 0:cfecfabc5e23 209 Standby();
clemente 0:cfecfabc5e23 210 readRegs( REG_CTRL_REG_1, &t, 1);
clemente 0:cfecfabc5e23 211
clemente 0:cfecfabc5e23 212 data[0] = REG_CTRL_REG_1;
clemente 0:cfecfabc5e23 213 data[1] = t|0x80;
clemente 0:cfecfabc5e23 214 writeRegs(data, 2);
clemente 0:cfecfabc5e23 215
clemente 0:cfecfabc5e23 216 data[0] = REG_PT_DATA_CFG;
clemente 0:cfecfabc5e23 217 data[1] = 0x07;
clemente 0:cfecfabc5e23 218 writeRegs(data, 2);
clemente 0:cfecfabc5e23 219
clemente 0:cfecfabc5e23 220 Oversample_Ratio( MPL3115A2_oversampling);
clemente 0:cfecfabc5e23 221
clemente 0:cfecfabc5e23 222 Active();
clemente 0:cfecfabc5e23 223
clemente 0:cfecfabc5e23 224 MPL3115A2_mode = ALTIMETER_MODE;
clemente 0:cfecfabc5e23 225 }
clemente 0:cfecfabc5e23 226
clemente 0:cfecfabc5e23 227 void MPL3115A2::Oversample_Ratio( unsigned int ratio)
clemente 0:cfecfabc5e23 228 {
clemente 0:cfecfabc5e23 229 unsigned char t;
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 t = t & 0xE7;
clemente 0:cfecfabc5e23 235 t = t | ( ratio<<3);
clemente 0:cfecfabc5e23 236
clemente 0:cfecfabc5e23 237 unsigned char data[2] = { REG_CTRL_REG_1, t};
clemente 0:cfecfabc5e23 238 writeRegs(data, 2);
clemente 0:cfecfabc5e23 239
clemente 0:cfecfabc5e23 240 Active();
clemente 0:cfecfabc5e23 241
clemente 0:cfecfabc5e23 242 MPL3115A2_oversampling = ratio;
clemente 0:cfecfabc5e23 243 }
clemente 0:cfecfabc5e23 244
clemente 0:cfecfabc5e23 245
clemente 0:cfecfabc5e23 246 void MPL3115A2::Active( void)
clemente 0:cfecfabc5e23 247 {
clemente 0:cfecfabc5e23 248 unsigned char t;
clemente 0:cfecfabc5e23 249
clemente 0:cfecfabc5e23 250 // Activate the peripheral
clemente 0:cfecfabc5e23 251 readRegs(REG_CTRL_REG_1, &t, 1);
clemente 0:cfecfabc5e23 252 unsigned char data[2] = {REG_CTRL_REG_1, t|0x01};
clemente 0:cfecfabc5e23 253 writeRegs(data, 2);
clemente 0:cfecfabc5e23 254 }
clemente 0:cfecfabc5e23 255
clemente 0:cfecfabc5e23 256 void MPL3115A2::Standby( void)
clemente 0:cfecfabc5e23 257 {
clemente 0:cfecfabc5e23 258 unsigned char t;
clemente 0:cfecfabc5e23 259
clemente 0:cfecfabc5e23 260 // Standby
clemente 0:cfecfabc5e23 261 readRegs(REG_CTRL_REG_1, &t, 1);
clemente 0:cfecfabc5e23 262 unsigned char data[2] = {REG_CTRL_REG_1, t&0xFE};
clemente 0:cfecfabc5e23 263 writeRegs(data, 2);
clemente 0:cfecfabc5e23 264 }
clemente 0:cfecfabc5e23 265
clemente 0:cfecfabc5e23 266 unsigned char MPL3115A2::getDeviceID() {
clemente 0:cfecfabc5e23 267 unsigned char device_id = 0;
clemente 0:cfecfabc5e23 268 readRegs(REG_WHO_AM_I, &device_id, 1);
clemente 0:cfecfabc5e23 269 return device_id;
clemente 0:cfecfabc5e23 270 }
clemente 0:cfecfabc5e23 271
clemente 0:cfecfabc5e23 272 unsigned int MPL3115A2::isDataAvailable( void)
clemente 0:cfecfabc5e23 273 {
clemente 0:cfecfabc5e23 274 unsigned char status;
clemente 0:cfecfabc5e23 275
clemente 0:cfecfabc5e23 276 readRegs( REG_STATUS, &status, 1);
clemente 0:cfecfabc5e23 277
clemente 0:cfecfabc5e23 278 if ( status & 0x08) {
clemente 0:cfecfabc5e23 279 return 1;
clemente 0:cfecfabc5e23 280 } else {
clemente 0:cfecfabc5e23 281 return 0;
clemente 0:cfecfabc5e23 282 }
clemente 0:cfecfabc5e23 283
clemente 0:cfecfabc5e23 284 }
clemente 0:cfecfabc5e23 285
clemente 0:cfecfabc5e23 286 unsigned char MPL3115A2::getStatus( void)
clemente 0:cfecfabc5e23 287 {
clemente 0:cfecfabc5e23 288 unsigned char status;
clemente 0:cfecfabc5e23 289
clemente 0:cfecfabc5e23 290 readRegs( REG_STATUS, &status, 1);
clemente 0:cfecfabc5e23 291 return status;
clemente 0:cfecfabc5e23 292 }
clemente 0:cfecfabc5e23 293
clemente 0:cfecfabc5e23 294 void MPL3115A2::getAllData( float *f)
clemente 0:cfecfabc5e23 295 {
clemente 0:cfecfabc5e23 296 if ( MPL3115A2_mode == ALTIMETER_MODE) {
clemente 0:cfecfabc5e23 297 f[0] = getAltimeter();
clemente 0:cfecfabc5e23 298 } else {
clemente 0:cfecfabc5e23 299 f[0] = getPressure();
clemente 0:cfecfabc5e23 300 }
clemente 0:cfecfabc5e23 301
clemente 0:cfecfabc5e23 302 f[1] = getTemperature();
clemente 0:cfecfabc5e23 303 }
clemente 0:cfecfabc5e23 304
clemente 0:cfecfabc5e23 305 float MPL3115A2::getAltimeter( void)
clemente 0:cfecfabc5e23 306 {
clemente 0:cfecfabc5e23 307 unsigned char dt[3];
clemente 0:cfecfabc5e23 308 unsigned short altm;
clemente 0:cfecfabc5e23 309 float faltm;
clemente 0:cfecfabc5e23 310
clemente 0:cfecfabc5e23 311 /*
clemente 0:cfecfabc5e23 312 * dt[0] = Bits 12-19 of 20-bit real-time Pressure sample. (b7-b0)
clemente 0:cfecfabc5e23 313 * dt[1] = Bits 4-11 of 20-bit real-time Pressure sample. (b7-b0)
clemente 0:cfecfabc5e23 314 * dt[2] = Bits 0-3 of 20-bit real-time Pressure sample (b7-b4)
clemente 0:cfecfabc5e23 315 */
clemente 0:cfecfabc5e23 316 readRegs( REG_ALTIMETER_MSB, &dt[0], 3);
clemente 0:cfecfabc5e23 317 altm = (dt[0]<<8) | dt[1];
clemente 0:cfecfabc5e23 318 //
clemente 0:cfecfabc5e23 319 if ( dt[0] > 0x7F) {
clemente 0:cfecfabc5e23 320 altm = ~altm + 1;
clemente 0:cfecfabc5e23 321 faltm = (float)altm * -1.0f;
clemente 0:cfecfabc5e23 322 } else {
clemente 0:cfecfabc5e23 323 faltm = (float)altm * 1.0f;
clemente 0:cfecfabc5e23 324 }
clemente 0:cfecfabc5e23 325 //
clemente 0:cfecfabc5e23 326 faltm = faltm+((float)(dt[2]>>4) * 0.0625f);
clemente 0:cfecfabc5e23 327 return faltm;
clemente 0:cfecfabc5e23 328 }
clemente 0:cfecfabc5e23 329
clemente 0:cfecfabc5e23 330 float MPL3115A2::getPressure( void)
clemente 0:cfecfabc5e23 331 {
clemente 0:cfecfabc5e23 332 unsigned char dt[3];
clemente 0:cfecfabc5e23 333 unsigned int prs;
clemente 0:cfecfabc5e23 334 float fprs;
clemente 0:cfecfabc5e23 335
clemente 0:cfecfabc5e23 336 /*
clemente 0:cfecfabc5e23 337 * dt[0] = Bits 12-19 of 20-bit real-time Pressure sample. (b7-b0)
clemente 0:cfecfabc5e23 338 * dt[1] = Bits 4-11 of 20-bit real-time Pressure sample. (b7-b0)
clemente 0:cfecfabc5e23 339 * dt[2] = Bits 0-3 of 20-bit real-time Pressure sample (b7-b4)
clemente 0:cfecfabc5e23 340 */
clemente 0:cfecfabc5e23 341 readRegs( REG_PRESSURE_MSB, &dt[0], 3);
clemente 0:cfecfabc5e23 342 prs = (dt[0]<<10) | (dt[1]<<2) | (dt[2]>>6);
clemente 0:cfecfabc5e23 343 //
clemente 0:cfecfabc5e23 344 fprs = (float)prs * 1.0f;
clemente 0:cfecfabc5e23 345
clemente 0:cfecfabc5e23 346 if ( dt[2] & 0x20)
clemente 0:cfecfabc5e23 347 fprs += 0.25f;
clemente 0:cfecfabc5e23 348 if ( dt[2] & 0x10)
clemente 0:cfecfabc5e23 349 fprs += 0.5f;
clemente 0:cfecfabc5e23 350
clemente 0:cfecfabc5e23 351 return fprs;
clemente 0:cfecfabc5e23 352 }
clemente 0:cfecfabc5e23 353
clemente 0:cfecfabc5e23 354
clemente 0:cfecfabc5e23 355 float MPL3115A2::getTemperature( void)
clemente 0:cfecfabc5e23 356 {
clemente 0:cfecfabc5e23 357 unsigned char dt[2];
clemente 0:cfecfabc5e23 358 unsigned short temp;
clemente 0:cfecfabc5e23 359 float ftemp;
clemente 0:cfecfabc5e23 360
clemente 0:cfecfabc5e23 361 /*
clemente 0:cfecfabc5e23 362 * dt[0] = Bits 4-11 of 16-bit real-time temperature sample. (b7-b0)
clemente 0:cfecfabc5e23 363 * dt[1] = Bits 0-3 of 16-bit real-time temperature sample. (b7-b4)
clemente 0:cfecfabc5e23 364 */
clemente 0:cfecfabc5e23 365 readRegs( REG_TEMP_MSB, &dt[0], 2);
clemente 0:cfecfabc5e23 366 temp = dt[0];
clemente 0:cfecfabc5e23 367 //
clemente 0:cfecfabc5e23 368 if ( dt[0] > 0x7F) {
clemente 0:cfecfabc5e23 369 temp = ~temp + 1;
clemente 0:cfecfabc5e23 370 ftemp = (float)temp * -1.0f;
clemente 0:cfecfabc5e23 371 } else {
clemente 0:cfecfabc5e23 372 ftemp = (float)temp * 1.0f;
clemente 0:cfecfabc5e23 373 }
clemente 0:cfecfabc5e23 374 //
clemente 0:cfecfabc5e23 375 ftemp = ftemp+((float)(dt[1]>>4) * 0.0625f);
clemente 0:cfecfabc5e23 376 return ftemp;
clemente 0:cfecfabc5e23 377
clemente 0:cfecfabc5e23 378 }
clemente 0:cfecfabc5e23 379
clemente 0:cfecfabc5e23 380 void MPL3115A2::readRegs(int addr, uint8_t * data, int len) {
clemente 0:cfecfabc5e23 381 char t[1] = {addr};
clemente 0:cfecfabc5e23 382 m_i2c.write(m_addr, t, 1, true);
clemente 0:cfecfabc5e23 383 m_i2c.read(m_addr, (char *)data, len);
clemente 0:cfecfabc5e23 384 }
clemente 0:cfecfabc5e23 385
clemente 0:cfecfabc5e23 386 void MPL3115A2::writeRegs(uint8_t * data, int len) {
clemente 0:cfecfabc5e23 387 m_i2c.write(m_addr, (char *)data, len);
clemente 0:cfecfabc5e23 388 }