Toyomasa Watarai / MPL3115A2

Llibrary for the WiGo MPL3115A2, I2C Precision Altimeter sensor.

MPL3115A2.cpp@12:e7122a94e812, 2019-11-10 (annotated)

Committer:
MACRUM
Date:
Sun Nov 10 03:38:04 2019 +0000
Revision:
12:e7122a94e812
Parent:
11:85da7a1b7954 
Fix API version issue

Who changed what in which revision?

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