clemente di caprio / MPL3115A2

Llibrary for the WiGo MPL3115A2, I2C Precision Altimeter sensor.

Dependents:   KL25Z_Batt_Test WIGO_MPL3115A2 Multi-Sensor SPACEmk2 ... more

30/05/2013 Added and tested the data acquisition using Interrupt. Added code for Altimeter trigger Interrupt but not yet tested.

Very basic library. Under development. Need to add in order: 1. IRQ configuration. 2. FIFO mode configuration.

MPL3115A2.cpp@11:a5ce3ee460b6, 2020-07-10 (annotated)

Committer:
clemente
Date:
Fri Jul 10 14:58:19 2020 +0000
Revision:
11:a5ce3ee460b6
Parent:
10:82ac06669316 
Added License

Who changed what in which revision?

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