Toyomasa Watarai / MPL3115A2

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

MPL3115A2.cpp@11:85da7a1b7954, 2019-11-10 (annotated)

Committer:
MACRUM
Date:
Sun Nov 10 01:46:07 2019 +0000
Revision:
11:85da7a1b7954
Parent:
10:82ac06669316
Child:
12:e7122a94e812
Fix build error by ARMC6

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