| 1 |
/** |
| 2 |
* collectd - src/barometer.c |
| 3 |
* |
| 4 |
* This program is free software; you can redistribute it and/or modify it |
| 5 |
* under the terms of the GNU Lesser General Public License as published by |
| 6 |
* the Free Software Foundation; only version 2.1 of the License is |
| 7 |
* applicable. |
| 8 |
* |
| 9 |
* This program is distributed in the hope that it will be useful, but |
| 10 |
* WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 12 |
* Lesser General Public License for more details. |
| 13 |
* |
| 14 |
* You should have received a copy of the GNU Lesser General Public License |
| 15 |
* along with this program; if not, write to the Free Software Foundation, |
| 16 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 17 |
* |
| 18 |
* Authors: |
| 19 |
* Tomas Menzl |
| 20 |
**/ |
| 21 |
|
| 22 |
#include "collectd.h" |
| 23 |
|
| 24 |
#include "plugin.h" |
| 25 |
#include "utils/common/common.h" |
| 26 |
#include "utils_cache.h" |
| 27 |
|
| 28 |
#include <fcntl.h> |
| 29 |
#include <linux/i2c-dev.h> |
| 30 |
#if HAVE_I2C_SMBUS_H |
| 31 |
#include <i2c/smbus.h> |
| 32 |
#endif |
| 33 |
#include <math.h> |
| 34 |
#include <stdint.h> |
| 35 |
#include <sys/ioctl.h> |
| 36 |
#include <unistd.h> |
| 37 |
|
| 38 |
/* ------------ MPL115 defines ------------ */ |
| 39 |
/* I2C address of the MPL115 sensor */ |
| 40 |
#define MPL115_I2C_ADDRESS 0x60 |
| 41 |
|
| 42 |
/* register addresses */ |
| 43 |
#define MPL115_ADDR_CONV 0x00 |
| 44 |
#define MPL115_ADDR_COEFFS 0x04 |
| 45 |
|
| 46 |
/* register sizes */ |
| 47 |
#define MPL115_NUM_CONV 4 |
| 48 |
#define MPL115_NUM_COEFFS 12 |
| 49 |
|
| 50 |
/* commands / addresses */ |
| 51 |
#define MPL115_CMD_CONVERT_PRESS 0x10 |
| 52 |
#define MPL115_CMD_CONVERT_TEMP 0x11 |
| 53 |
#define MPL115_CMD_CONVERT_BOTH 0x12 |
| 54 |
|
| 55 |
#define MPL115_CONVERSION_RETRIES 5 |
| 56 |
|
| 57 |
/* ------------ MPL3115 defines ------------ */ |
| 58 |
/* MPL3115 I2C address */ |
| 59 |
#define MPL3115_I2C_ADDRESS 0x60 |
| 60 |
|
| 61 |
/* register addresses (only the interesting ones) */ |
| 62 |
#define MPL3115_REG_STATUS 0x00 |
| 63 |
#define MPL3115_REG_OUT_P_MSB 0x01 |
| 64 |
#define MPL3115_REG_OUT_P_CSB 0x02 |
| 65 |
#define MPL3115_REG_OUT_P_LSB 0x03 |
| 66 |
#define MPL3115_REG_OUT_T_MSB 0x04 |
| 67 |
#define MPL3115_REG_OUT_T_LSB 0x05 |
| 68 |
#define MPL3115_REG_DR_STATUS 0x06 |
| 69 |
#define MPL3115_REG_WHO_AM_I 0x0C |
| 70 |
#define MPL3115_REG_SYSMOD 0x11 |
| 71 |
#define MPL3115_REG_PT_DATA_CFG 0x13 |
| 72 |
#define MPL3115_REG_BAR_IN_MSB 0x14 |
| 73 |
#define MPL3115_REG_BAR_IN_LSB 0x15 |
| 74 |
#define MPL3115_REG_CTRL_REG1 0x26 |
| 75 |
#define MPL3115_REG_CTRL_REG2 0x27 |
| 76 |
#define MPL3115_REG_CTRL_REG3 0x28 |
| 77 |
#define MPL3115_REG_CTRL_REG4 0x29 |
| 78 |
#define MPL3115_REG_CTRL_REG5 0x2A |
| 79 |
#define MPL3115_REG_OFF_P 0x2B |
| 80 |
#define MPL3115_REG_OFF_T 0x2C |
| 81 |
#define MPL3115_REG_OFF_H 0x2D |
| 82 |
|
| 83 |
/* Register values, masks */ |
| 84 |
#define MPL3115_WHO_AM_I_RESP 0xC4 |
| 85 |
|
| 86 |
#define MPL3115_PT_DATA_DREM 0x04 |
| 87 |
#define MPL3115_PT_DATA_PDEF 0x02 |
| 88 |
#define MPL3115_PT_DATA_TDEF 0x01 |
| 89 |
|
| 90 |
#define MPL3115_DR_STATUS_TDR 0x02 |
| 91 |
#define MPL3115_DR_STATUS_PDR 0x04 |
| 92 |
#define MPL3115_DR_STATUS_PTDR 0x08 |
| 93 |
#define MPL3115_DR_STATUS_DR \ |
| 94 |
(MPL3115_DR_STATUS_TDR | MPL3115_DR_STATUS_PDR | MPL3115_DR_STATUS_PTDR) |
| 95 |
|
| 96 |
#define MPL3115_DR_STATUS_TOW 0x20 |
| 97 |
#define MPL3115_DR_STATUS_POW 0x40 |
| 98 |
#define MPL3115_DR_STATUS_PTOW 0x80 |
| 99 |
|
| 100 |
#define MPL3115_CTRL_REG1_ALT 0x80 |
| 101 |
#define MPL3115_CTRL_REG1_RAW 0x40 |
| 102 |
#define MPL3115_CTRL_REG1_OST_MASK 0x38 |
| 103 |
#define MPL3115_CTRL_REG1_OST_1 0x00 |
| 104 |
#define MPL3115_CTRL_REG1_OST_2 0x08 |
| 105 |
#define MPL3115_CTRL_REG1_OST_4 0x10 |
| 106 |
#define MPL3115_CTRL_REG1_OST_8 0x18 |
| 107 |
#define MPL3115_CTRL_REG1_OST_16 0x20 |
| 108 |
#define MPL3115_CTRL_REG1_OST_32 0x28 |
| 109 |
#define MPL3115_CTRL_REG1_OST_64 0x30 |
| 110 |
#define MPL3115_CTRL_REG1_OST_128 0x38 |
| 111 |
#define MPL3115_CTRL_REG1_RST 0x04 |
| 112 |
#define MPL3115_CTRL_REG1_OST 0x02 |
| 113 |
#define MPL3115_CTRL_REG1_SBYB 0x01 |
| 114 |
#define MPL3115_CTRL_REG1_SBYB_MASK 0xFE |
| 115 |
|
| 116 |
#define MPL3115_NUM_CONV_VALS 5 |
| 117 |
|
| 118 |
/* ------------ BMP085 defines ------------ */ |
| 119 |
/* I2C address of the BMP085 sensor */ |
| 120 |
#define BMP085_I2C_ADDRESS 0x77 |
| 121 |
|
| 122 |
/* register addresses */ |
| 123 |
#define BMP085_ADDR_ID_REG 0xD0 |
| 124 |
#define BMP085_ADDR_VERSION 0xD1 |
| 125 |
|
| 126 |
#define BMP085_ADDR_CONV 0xF6 |
| 127 |
|
| 128 |
#define BMP085_ADDR_CTRL_REG 0xF4 |
| 129 |
#define BMP085_ADDR_COEFFS 0xAA |
| 130 |
|
| 131 |
/* register sizes */ |
| 132 |
#define BMP085_NUM_COEFFS 22 |
| 133 |
|
| 134 |
/* commands, values */ |
| 135 |
#define BMP085_CHIP_ID 0x55 |
| 136 |
|
| 137 |
#define BMP085_CMD_CONVERT_TEMP 0x2E |
| 138 |
|
| 139 |
#define BMP085_CMD_CONVERT_PRESS_0 0x34 |
| 140 |
#define BMP085_CMD_CONVERT_PRESS_1 0x74 |
| 141 |
#define BMP085_CMD_CONVERT_PRESS_2 0xB4 |
| 142 |
#define BMP085_CMD_CONVERT_PRESS_3 0xF4 |
| 143 |
|
| 144 |
/* in us */ |
| 145 |
#define BMP085_TIME_CNV_TEMP 4500 |
| 146 |
|
| 147 |
#define BMP085_TIME_CNV_PRESS_0 4500 |
| 148 |
#define BMP085_TIME_CNV_PRESS_1 7500 |
| 149 |
#define BMP085_TIME_CNV_PRESS_2 13500 |
| 150 |
#define BMP085_TIME_CNV_PRESS_3 25500 |
| 151 |
|
| 152 |
/* ------------ Normalization ------------ */ |
| 153 |
/* Mean sea level pressure normalization methods */ |
| 154 |
#define MSLP_NONE 0 |
| 155 |
#define MSLP_INTERNATIONAL 1 |
| 156 |
#define MSLP_DEU_WETT 2 |
| 157 |
|
| 158 |
/** Temperature reference history depth for averaging. See |
| 159 |
* #get_reference_temperature */ |
| 160 |
#define REF_TEMP_AVG_NUM 5 |
| 161 |
|
| 162 |
/* ------------------------------------------ */ |
| 163 |
|
| 164 |
/** Supported sensor types */ |
| 165 |
enum Sensor_type { |
| 166 |
Sensor_none = 0, |
| 167 |
Sensor_MPL115, |
| 168 |
Sensor_MPL3115, |
| 169 |
Sensor_BMP085 |
| 170 |
}; |
| 171 |
|
| 172 |
static const char *config_keys[] = { |
| 173 |
"Device", |
| 174 |
"Oversampling", |
| 175 |
"PressureOffset", /**< only for MPL3115 */ |
| 176 |
"TemperatureOffset", /**< only for MPL3115 */ |
| 177 |
"Altitude", |
| 178 |
"Normalization", |
| 179 |
"TemperatureSensor"}; |
| 180 |
|
| 181 |
static int config_keys_num = STATIC_ARRAY_SIZE(config_keys); |
| 182 |
|
| 183 |
static char *config_device; /**< I2C bus device */ |
| 184 |
static int config_oversample = 1; /**< averaging window */ |
| 185 |
|
| 186 |
static double config_press_offset; /**< pressure offset */ |
| 187 |
static double config_temp_offset; /**< temperature offset */ |
| 188 |
|
| 189 |
static double config_altitude = NAN; /**< altitude */ |
| 190 |
static int config_normalize; /**< normalization method */ |
| 191 |
|
| 192 |
static bool configured; /**< the whole plugin config status */ |
| 193 |
|
| 194 |
static int i2c_bus_fd = -1; /**< I2C bus device FD */ |
| 195 |
|
| 196 |
static enum Sensor_type sensor_type = |
| 197 |
Sensor_none; /**< detected/used sensor type */ |
| 198 |
|
| 199 |
static __s32 mpl3115_oversample; /**< MPL3115 CTRL1 oversample setting */ |
| 200 |
|
| 201 |
// BMP085 configuration |
| 202 |
static unsigned bmp085_oversampling; /**< BMP085 oversampling (0-3) */ |
| 203 |
static unsigned long |
| 204 |
bmp085_timeCnvPress; /**< BMP085 conversion time for pressure in us */ |
| 205 |
static __u8 bmp085_cmdCnvPress; /**< BMP085 pressure conversion command */ |
| 206 |
|
| 207 |
/* MPL115 conversion coefficients */ |
| 208 |
static double mpl115_coeffA0; |
| 209 |
static double mpl115_coeffB1; |
| 210 |
static double mpl115_coeffB2; |
| 211 |
static double mpl115_coeffC12; |
| 212 |
static double mpl115_coeffC11; |
| 213 |
static double mpl115_coeffC22; |
| 214 |
|
| 215 |
/* BMP085 conversion coefficients */ |
| 216 |
static short bmp085_AC1; |
| 217 |
static short bmp085_AC2; |
| 218 |
static short bmp085_AC3; |
| 219 |
static unsigned short bmp085_AC4; |
| 220 |
static unsigned short bmp085_AC5; |
| 221 |
static unsigned short bmp085_AC6; |
| 222 |
static short bmp085_B1; |
| 223 |
static short bmp085_B2; |
| 224 |
static short bmp085_MB; |
| 225 |
static short bmp085_MC; |
| 226 |
static short bmp085_MD; |
| 227 |
|
| 228 |
/* ------------------------ averaging ring buffer ------------------------ */ |
| 229 |
/* Used only for MPL115. MPL3115 supports real oversampling in the device so */ |
| 230 |
/* no need for any postprocessing. */ |
| 231 |
|
| 232 |
static bool avg_initialized; /**< already initialized by real values */ |
| 233 |
|
| 234 |
typedef struct averaging_s { |
| 235 |
long int *ring_buffer; |
| 236 |
int ring_buffer_size; |
| 237 |
long int ring_buffer_sum; |
| 238 |
int ring_buffer_head; |
| 239 |
} averaging_t; |
| 240 |
|
| 241 |
static averaging_t pressure_averaging; |
| 242 |
static averaging_t temperature_averaging; |
| 243 |
|
| 244 |
/** |
| 245 |
* Create / allocate averaging buffer |
| 246 |
* |
| 247 |
* The buffer is initialized with zeros. |
| 248 |
* |
| 249 |
* @param avg pointer to ring buffer to be allocated |
| 250 |
* @param size requested buffer size |
| 251 |
* |
| 252 |
* @return Zero when successful |
| 253 |
*/ |
| 254 |
static int averaging_create(averaging_t *avg, int size) { |
| 255 |
avg->ring_buffer = calloc(size, sizeof(*avg->ring_buffer)); |
| 256 |
if (avg->ring_buffer == NULL) { |
| 257 |
ERROR("barometer: averaging_create - ring buffer allocation of size %d " |
| 258 |
"failed", |
| 259 |
size); |
| 260 |
return -1; |
| 261 |
} |
| 262 |
|
| 263 |
avg->ring_buffer_size = size; |
| 264 |
avg->ring_buffer_sum = 0L; |
| 265 |
avg->ring_buffer_head = 0; |
| 266 |
|
| 267 |
return 0; |
| 268 |
} |
| 269 |
|
| 270 |
/** |
| 271 |
* Delete / free existing averaging buffer |
| 272 |
* |
| 273 |
* @param avg pointer to the ring buffer to be deleted |
| 274 |
*/ |
| 275 |
static void averaging_delete(averaging_t *avg) { |
| 276 |
if (avg->ring_buffer != NULL) { |
| 277 |
free(avg->ring_buffer); |
| 278 |
avg->ring_buffer = NULL; |
| 279 |
} |
| 280 |
avg->ring_buffer_size = 0; |
| 281 |
avg->ring_buffer_sum = 0L; |
| 282 |
avg->ring_buffer_head = 0; |
| 283 |
} |
| 284 |
|
| 285 |
/* |
| 286 |
* Add new sample to the averaging buffer |
| 287 |
* |
| 288 |
* A new averaged value is returned. Note that till the buffer is full |
| 289 |
* returned value is inaccurate as it is an average of real values and initial |
| 290 |
* zeros. |
| 291 |
* |
| 292 |
* @param avg pointer to the ring buffer |
| 293 |
* @param sample new sample value |
| 294 |
* |
| 295 |
* @return Averaged sample value |
| 296 |
*/ |
| 297 |
static double averaging_add_sample(averaging_t *avg, long int sample) { |
| 298 |
double result; |
| 299 |
|
| 300 |
avg->ring_buffer_sum += sample - avg->ring_buffer[avg->ring_buffer_head]; |
| 301 |
avg->ring_buffer[avg->ring_buffer_head] = sample; |
| 302 |
avg->ring_buffer_head = (avg->ring_buffer_head + 1) % avg->ring_buffer_size; |
| 303 |
result = (double)(avg->ring_buffer_sum) / (double)(avg->ring_buffer_size); |
| 304 |
|
| 305 |
DEBUG("barometer: averaging_add_sample - added %ld, result = %lf", sample, |
| 306 |
result); |
| 307 |
|
| 308 |
return result; |
| 309 |
} |
| 310 |
|
| 311 |
/* ------------------------ temperature refference ------------------------ */ |
| 312 |
|
| 313 |
/** |
| 314 |
* Linked list type of temperature sensor references |
| 315 |
*/ |
| 316 |
typedef struct temperature_list_s { |
| 317 |
char *sensor_name; /**< sensor name/reference */ |
| 318 |
size_t num_values; /**< number of values (usually one) */ |
| 319 |
bool initialized; /**< sensor already provides data */ |
| 320 |
struct temperature_list_s *next; /**< next in the list */ |
| 321 |
} temperature_list_t; |
| 322 |
|
| 323 |
static temperature_list_t *temp_list; |
| 324 |
|
| 325 |
/* |
| 326 |
* Add new sensor to the temperature reference list |
| 327 |
* |
| 328 |
* @param list the list |
| 329 |
* @param sensor reference name (as provided by the config file) |
| 330 |
* |
| 331 |
* @return Zero when successful |
| 332 |
*/ |
| 333 |
static int temp_list_add(temperature_list_t *list, const char *sensor) { |
| 334 |
temperature_list_t *new_temp; |
| 335 |
|
| 336 |
new_temp = malloc(sizeof(*new_temp)); |
| 337 |
if (new_temp == NULL) |
| 338 |
return -1; |
| 339 |
|
| 340 |
new_temp->sensor_name = strdup(sensor); |
| 341 |
new_temp->initialized = 0; |
| 342 |
new_temp->num_values = 0; |
| 343 |
if (new_temp->sensor_name == NULL) { |
| 344 |
free(new_temp); |
| 345 |
return -1; |
| 346 |
} |
| 347 |
|
| 348 |
new_temp->next = temp_list; |
| 349 |
temp_list = new_temp; |
| 350 |
return 0; |
| 351 |
} |
| 352 |
|
| 353 |
/* |
| 354 |
* Delete the whole temperature reference list |
| 355 |
* |
| 356 |
* @param list the list to be deleted |
| 357 |
*/ |
| 358 |
static void temp_list_delete(temperature_list_t **list) { |
| 359 |
temperature_list_t *tmp; |
| 360 |
|
| 361 |
while (*list != NULL) { |
| 362 |
tmp = (*list); |
| 363 |
(*list) = (*list)->next; |
| 364 |
free(tmp->sensor_name); |
| 365 |
free(tmp); |
| 366 |
tmp = NULL; |
| 367 |
} |
| 368 |
} |
| 369 |
|
| 370 |
/* |
| 371 |
* Get reference temperature value |
| 372 |
* |
| 373 |
* First initially uc_get_rate_by_name is tried. At the startup due to |
| 374 |
* nondeterministic order the temperature may not be read yet (then it fails and |
| 375 |
* first measurment gives only absolute air pressure reading which is |
| 376 |
* acceptable). Once it succedes (should be second measurement at the latest) we |
| 377 |
* use average of few last readings from uc_get_history_by_name. It may take few |
| 378 |
* readings to start filling so again we use uc_get_rate_by_name as a fallback. |
| 379 |
* The idea is to use basic "noise" filtering (history averaging) across all the |
| 380 |
* values which given sensor provides (up to given depth). Then we get minimum |
| 381 |
* among the sensors. |
| 382 |
* |
| 383 |
* @param result where the result is stored. When not available NAN is stored. |
| 384 |
* |
| 385 |
* @return Zero when successful |
| 386 |
*/ |
| 387 |
static int get_reference_temperature(double *result) { |
| 388 |
temperature_list_t *list = temp_list; |
| 389 |
|
| 390 |
gauge_t *values = NULL; /**< rate values */ |
| 391 |
size_t values_num = 0; /**< number of rate values */ |
| 392 |
|
| 393 |
gauge_t values_history[REF_TEMP_AVG_NUM]; |
| 394 |
|
| 395 |
double avg_sum; /**< Value sum for computing average */ |
| 396 |
int avg_num; /**< Number of values for computing average */ |
| 397 |
double average; /**< Resulting value average */ |
| 398 |
|
| 399 |
*result = NAN; |
| 400 |
|
| 401 |
while (list != NULL) { |
| 402 |
avg_sum = 0.0; |
| 403 |
avg_num = 0; |
| 404 |
|
| 405 |
/* First time need to read current rate to learn how many values are |
| 406 |
there (typically for temperature it would be just one). We do not expect |
| 407 |
dynamic changing of number of temperarure values in runtime yet (are |
| 408 |
there any such cases?). */ |
| 409 |
if (!list->initialized) { |
| 410 |
if (uc_get_rate_by_name(list->sensor_name, &values, &values_num)) { |
| 411 |
DEBUG( |
| 412 |
"barometer: get_reference_temperature - rate \"%s\" not found yet", |
| 413 |
list->sensor_name); |
| 414 |
list = list->next; |
| 415 |
continue; |
| 416 |
} |
| 417 |
|
| 418 |
DEBUG("barometer: get_reference_temperature - initialize \"%s\", %" PRIsz |
| 419 |
" vals", |
| 420 |
list->sensor_name, values_num); |
| 421 |
|
| 422 |
list->initialized = 1; |
| 423 |
list->num_values = values_num; |
| 424 |
|
| 425 |
for (size_t i = 0; i < values_num; ++i) { |
| 426 |
DEBUG("barometer: get_reference_temperature - rate %" PRIsz ": %lf **", |
| 427 |
i, values[i]); |
| 428 |
if (!isnan(values[i])) { |
| 429 |
avg_sum += values[i]; |
| 430 |
++avg_num; |
| 431 |
} |
| 432 |
} |
| 433 |
free(values); |
| 434 |
values = NULL; |
| 435 |
} |
| 436 |
|
| 437 |
/* It is OK to get here the first time as well, in the worst case |
| 438 |
the history will full of NANs. */ |
| 439 |
if (uc_get_history_by_name(list->sensor_name, values_history, |
| 440 |
REF_TEMP_AVG_NUM, list->num_values)) { |
| 441 |
ERROR("barometer: get_reference_temperature - history \"%s\" lost", |
| 442 |
list->sensor_name); |
| 443 |
list->initialized = 0; |
| 444 |
list->num_values = 0; |
| 445 |
list = list->next; |
| 446 |
continue; |
| 447 |
} |
| 448 |
|
| 449 |
for (size_t i = 0; i < REF_TEMP_AVG_NUM * list->num_values; ++i) { |
| 450 |
DEBUG("barometer: get_reference_temperature - history %" PRIsz ": %lf", i, |
| 451 |
values_history[i]); |
| 452 |
if (!isnan(values_history[i])) { |
| 453 |
avg_sum += values_history[i]; |
| 454 |
++avg_num; |
| 455 |
} |
| 456 |
} |
| 457 |
|
| 458 |
if (avg_num == 0) /* still no history? fallback to current */ |
| 459 |
{ |
| 460 |
if (uc_get_rate_by_name(list->sensor_name, &values, &values_num)) { |
| 461 |
ERROR("barometer: get_reference_temperature - rate \"%s\" lost", |
| 462 |
list->sensor_name); |
| 463 |
list->initialized = 0; |
| 464 |
list->num_values = 0; |
| 465 |
list = list->next; |
| 466 |
continue; |
| 467 |
} |
| 468 |
|
| 469 |
for (size_t i = 0; i < values_num; ++i) { |
| 470 |
DEBUG("barometer: get_reference_temperature - rate last %" PRIsz |
| 471 |
": %lf **", |
| 472 |
i, values[i]); |
| 473 |
if (!isnan(values[i])) { |
| 474 |
avg_sum += values[i]; |
| 475 |
++avg_num; |
| 476 |
} |
| 477 |
} |
| 478 |
free(values); |
| 479 |
values = NULL; |
| 480 |
} |
| 481 |
|
| 482 |
if (avg_num == 0) { |
| 483 |
ERROR("barometer: get_reference_temperature - could not read \"%s\"", |
| 484 |
list->sensor_name); |
| 485 |
list->initialized = 0; |
| 486 |
list->num_values = 0; |
| 487 |
} else { |
| 488 |
average = avg_sum / (double)avg_num; |
| 489 |
if (isnan(*result)) |
| 490 |
*result = average; |
| 491 |
else if (*result > average) |
| 492 |
*result = average; |
| 493 |
} |
| 494 |
list = list->next; |
| 495 |
} /* while sensor list */ |
| 496 |
|
| 497 |
if (*result == NAN) { |
| 498 |
ERROR("barometer: get_reference_temperature - no sensor available (yet?)"); |
| 499 |
return -1; |
| 500 |
} |
| 501 |
DEBUG("barometer: get_reference_temperature - temp is %lf", *result); |
| 502 |
return 0; |
| 503 |
} |
| 504 |
|
| 505 |
/* ------------------------ MPL115 access ------------------------ */ |
| 506 |
|
| 507 |
/** |
| 508 |
* Detect presence of a MPL115 pressure sensor. |
| 509 |
* |
| 510 |
* Unfortunately there seems to be no ID register so we just try to read first |
| 511 |
* conversion coefficient from device at MPL115 address and hope it is really |
| 512 |
* MPL115. We should use this check as the last resort (which would be the |
| 513 |
* typical |
| 514 |
* case anyway since MPL115 is the least accurate sensor). |
| 515 |
* As a sideeffect will leave set I2C slave address. |
| 516 |
* |
| 517 |
* @return 1 if MPL115, 0 otherwise |
| 518 |
*/ |
| 519 |
static int MPL115_detect(void) { |
| 520 |
__s32 res; |
| 521 |
|
| 522 |
if (ioctl(i2c_bus_fd, I2C_SLAVE_FORCE, MPL115_I2C_ADDRESS) < 0) { |
| 523 |
ERROR("barometer: MPL115_detect problem setting i2c slave address to " |
| 524 |
"0x%02X: %s", |
| 525 |
MPL115_I2C_ADDRESS, STRERRNO); |
| 526 |
return 0; |
| 527 |
} |
| 528 |
|
| 529 |
res = i2c_smbus_read_byte_data(i2c_bus_fd, MPL115_ADDR_COEFFS); |
| 530 |
if (res >= 0) { |
| 531 |
DEBUG("barometer: MPL115_detect - positive detection"); |
| 532 |
return 1; |
| 533 |
} |
| 534 |
|
| 535 |
DEBUG("barometer: MPL115_detect - negative detection"); |
| 536 |
return 0; |
| 537 |
} |
| 538 |
|
| 539 |
/** |
| 540 |
* Read the MPL115 sensor conversion coefficients. |
| 541 |
* |
| 542 |
* These are (device specific) constants so we can read them just once. |
| 543 |
* |
| 544 |
* @return Zero when successful |
| 545 |
*/ |
| 546 |
static int MPL115_read_coeffs(void) { |
| 547 |
uint8_t mpl115_coeffs[MPL115_NUM_COEFFS] = {0}; |
| 548 |
int32_t res; |
| 549 |
|
| 550 |
int8_t sia0MSB, sia0LSB, sib1MSB, sib1LSB, sib2MSB, sib2LSB; |
| 551 |
int8_t sic12MSB, sic12LSB, sic11MSB, sic11LSB, sic22MSB, sic22LSB; |
| 552 |
int16_t sia0, sib1, sib2, sic12, sic11, sic22; |
| 553 |
|
| 554 |
res = i2c_smbus_read_i2c_block_data(i2c_bus_fd, MPL115_ADDR_COEFFS, |
| 555 |
STATIC_ARRAY_SIZE(mpl115_coeffs), |
| 556 |
mpl115_coeffs); |
| 557 |
if (res < 0) { |
| 558 |
ERROR("barometer: MPL115_read_coeffs - problem reading data: %s", STRERRNO); |
| 559 |
return -1; |
| 560 |
} |
| 561 |
|
| 562 |
/* Using perhaps less elegant/efficient code, but more readable. */ |
| 563 |
/* a0: 16total 1sign 12int 4fract 0pad */ |
| 564 |
sia0MSB = mpl115_coeffs[0]; |
| 565 |
sia0LSB = mpl115_coeffs[1]; |
| 566 |
sia0 = (int16_t)sia0MSB << 8; /* s16 type, Shift to MSB */ |
| 567 |
sia0 += (int16_t)sia0LSB & 0x00FF; /* Add LSB to 16bit number */ |
| 568 |
mpl115_coeffA0 = (double)(sia0); |
| 569 |
mpl115_coeffA0 /= 8.0; /* 3 fract bits */ |
| 570 |
|
| 571 |
/* b1: 16total 1sign 2int 13fract 0pad */ |
| 572 |
sib1MSB = mpl115_coeffs[2]; |
| 573 |
sib1LSB = mpl115_coeffs[3]; |
| 574 |
sib1 = sib1MSB << 8; /* Shift to MSB */ |
| 575 |
sib1 += sib1LSB & 0x00FF; /* Add LSB to 16bit number */ |
| 576 |
mpl115_coeffB1 = (double)(sib1); |
| 577 |
mpl115_coeffB1 /= 8192.0; /* 13 fract */ |
| 578 |
|
| 579 |
/* b2: 16total 1sign 1int 14fract 0pad */ |
| 580 |
sib2MSB = mpl115_coeffs[4]; |
| 581 |
sib2LSB = mpl115_coeffs[5]; |
| 582 |
sib2 = sib2MSB << 8; /* Shift to MSB */ |
| 583 |
sib2 += sib2LSB & 0x00FF; /* Add LSB to 16bit number */ |
| 584 |
mpl115_coeffB2 = (double)(sib2); |
| 585 |
mpl115_coeffB2 /= 16384.0; /* 14 fract */ |
| 586 |
|
| 587 |
/* c12: 14total 1sign 0int 13fract 9pad */ |
| 588 |
sic12MSB = mpl115_coeffs[6]; |
| 589 |
sic12LSB = mpl115_coeffs[7]; |
| 590 |
sic12 = sic12MSB << 8; /* Shift to MSB only by 8 for MSB */ |
| 591 |
sic12 += sic12LSB & 0x00FF; |
| 592 |
mpl115_coeffC12 = (double)(sic12); |
| 593 |
mpl115_coeffC12 /= 4.0; /* 16-14=2 */ |
| 594 |
mpl115_coeffC12 /= 4194304.0; /* 13+9=22 fract */ |
| 595 |
|
| 596 |
/* c11: 11total 1sign 0int 11fract 11pad */ |
| 597 |
sic11MSB = mpl115_coeffs[8]; |
| 598 |
sic11LSB = mpl115_coeffs[9]; |
| 599 |
sic11 = sic11MSB << 8; /* Shift to MSB only by 8 for MSB */ |
| 600 |
sic11 += sic11LSB & 0x00FF; |
| 601 |
mpl115_coeffC11 = (double)(sic11); |
| 602 |
mpl115_coeffC11 /= 32.0; /* 16-11=5 */ |
| 603 |
mpl115_coeffC11 /= 4194304.0; /* 11+11=22 fract */ |
| 604 |
|
| 605 |
/* c12: 11total 1sign 0int 10fract 15pad */ |
| 606 |
sic22MSB = mpl115_coeffs[10]; |
| 607 |
sic22LSB = mpl115_coeffs[11]; |
| 608 |
sic22 = sic22MSB << 8; /* Shift to MSB only by 8 for MSB */ |
| 609 |
sic22 += sic22LSB & 0x00FF; |
| 610 |
mpl115_coeffC22 = (double)(sic22); |
| 611 |
mpl115_coeffC22 /= 32.0; // 16-11=5 |
| 612 |
mpl115_coeffC22 /= 33554432.0; /* 10+15=25 fract */ |
| 613 |
|
| 614 |
DEBUG("barometer: MPL115_read_coeffs: a0=%lf, b1=%lf, b2=%lf, c12=%lf, " |
| 615 |
"c11=%lf, c22=%lf", |
| 616 |
mpl115_coeffA0, mpl115_coeffB1, mpl115_coeffB2, mpl115_coeffC12, |
| 617 |
mpl115_coeffC11, mpl115_coeffC22); |
| 618 |
return 0; |
| 619 |
} |
| 620 |
|
| 621 |
/** |
| 622 |
* Convert raw adc values to real data using the sensor coefficients. |
| 623 |
* |
| 624 |
* @param adc_pressure adc pressure value to be converted |
| 625 |
* @param adc_temp adc temperature value to be converted |
| 626 |
* @param pressure computed real pressure |
| 627 |
* @param temperature computed real temperature |
| 628 |
*/ |
| 629 |
static void MPL115_convert_adc_to_real(double adc_pressure, double adc_temp, |
| 630 |
double *pressure, double *temperature) { |
| 631 |
double Pcomp; |
| 632 |
Pcomp = mpl115_coeffA0 + |
| 633 |
(mpl115_coeffB1 + mpl115_coeffC11 * adc_pressure + |
| 634 |
mpl115_coeffC12 * adc_temp) * |
| 635 |
adc_pressure + |
| 636 |
(mpl115_coeffB2 + mpl115_coeffC22 * adc_temp) * adc_temp; |
| 637 |
|
| 638 |
*pressure = ((1150.0 - 500.0) * Pcomp / 1023.0) + 500.0; |
| 639 |
*temperature = (472.0 - adc_temp) / 5.35 + 25.0; |
| 640 |
DEBUG("barometer: MPL115_convert_adc_to_real - got %lf hPa, %lf C", *pressure, |
| 641 |
*temperature); |
| 642 |
} |
| 643 |
|
| 644 |
/** |
| 645 |
* Read sensor averegaed measurements |
| 646 |
* |
| 647 |
* @param pressure averaged measured pressure |
| 648 |
* @param temperature averaged measured temperature |
| 649 |
* |
| 650 |
* @return Zero when successful |
| 651 |
*/ |
| 652 |
static int MPL115_read_averaged(double *pressure, double *temperature) { |
| 653 |
uint8_t mpl115_conv[MPL115_NUM_CONV] = {0}; |
| 654 |
int8_t res; |
| 655 |
int retries; |
| 656 |
int conv_pressure; |
| 657 |
int conv_temperature; |
| 658 |
double adc_pressure; |
| 659 |
double adc_temperature; |
| 660 |
|
| 661 |
*pressure = 0.0; |
| 662 |
*temperature = 0.0; |
| 663 |
|
| 664 |
/* start conversion of both temp and presure */ |
| 665 |
retries = MPL115_CONVERSION_RETRIES; |
| 666 |
while (retries > 0) { |
| 667 |
/* write 1 to start conversion */ |
| 668 |
res = i2c_smbus_write_byte_data(i2c_bus_fd, MPL115_CMD_CONVERT_BOTH, 0x01); |
| 669 |
if (res >= 0) |
| 670 |
break; |
| 671 |
|
| 672 |
--retries; |
| 673 |
if (retries > 0) { |
| 674 |
ERROR("barometer: MPL115_read_averaged - requesting conversion: %s, " |
| 675 |
"will retry at most %d more times", |
| 676 |
STRERRNO, retries); |
| 677 |
} else { |
| 678 |
ERROR("barometer: MPL115_read_averaged - requesting conversion: %s, " |
| 679 |
"too many failed retries", |
| 680 |
STRERRNO); |
| 681 |
return -1; |
| 682 |
} |
| 683 |
} |
| 684 |
|
| 685 |
usleep(10000); /* wait 10ms for the conversion */ |
| 686 |
|
| 687 |
retries = MPL115_CONVERSION_RETRIES; |
| 688 |
while (retries > 0) { |
| 689 |
res = i2c_smbus_read_i2c_block_data(i2c_bus_fd, MPL115_ADDR_CONV, |
| 690 |
STATIC_ARRAY_SIZE(mpl115_conv), |
| 691 |
mpl115_conv); |
| 692 |
if (res >= 0) |
| 693 |
break; |
| 694 |
|
| 695 |
--retries; |
| 696 |
if (retries > 0) { |
| 697 |
ERROR("barometer: MPL115_read_averaged - reading conversion: %s, " |
| 698 |
"will retry at most %d more times", |
| 699 |
STRERRNO, retries); |
| 700 |
} else { |
| 701 |
ERROR("barometer: MPL115_read_averaged - reading conversion: %s, " |
| 702 |
"too many failed retries", |
| 703 |
STRERRNO); |
| 704 |
return -1; |
| 705 |
} |
| 706 |
} |
| 707 |
|
| 708 |
conv_pressure = ((mpl115_conv[0] << 8) | mpl115_conv[1]) >> 6; |
| 709 |
conv_temperature = ((mpl115_conv[2] << 8) | mpl115_conv[3]) >> 6; |
| 710 |
DEBUG("barometer: MPL115_read_averaged, raw pressure ADC value = %d, " |
| 711 |
"raw temperature ADC value = %d", |
| 712 |
conv_pressure, conv_temperature); |
| 713 |
|
| 714 |
adc_pressure = averaging_add_sample(&pressure_averaging, conv_pressure); |
| 715 |
adc_temperature = |
| 716 |
averaging_add_sample(&temperature_averaging, conv_temperature); |
| 717 |
|
| 718 |
MPL115_convert_adc_to_real(adc_pressure, adc_temperature, pressure, |
| 719 |
temperature); |
| 720 |
|
| 721 |
DEBUG("barometer: MPL115_read_averaged - averaged ADC pressure = %lf / " |
| 722 |
"temperature = %lf, " |
| 723 |
"real pressure = %lf hPa / temperature = %lf C", |
| 724 |
adc_pressure, adc_temperature, *pressure, *temperature); |
| 725 |
|
| 726 |
return 0; |
| 727 |
} |
| 728 |
|
| 729 |
/* ------------------------ MPL3115 access ------------------------ */ |
| 730 |
|
| 731 |
/** |
| 732 |
* Detect presence of a MPL3115 pressure sensor by checking register "WHO AM I" |
| 733 |
* |
| 734 |
* As a sideeffect will leave set I2C slave address. |
| 735 |
* |
| 736 |
* @return 1 if MPL3115, 0 otherwise |
| 737 |
*/ |
| 738 |
static int MPL3115_detect(void) { |
| 739 |
__s32 res; |
| 740 |
|
| 741 |
if (ioctl(i2c_bus_fd, I2C_SLAVE_FORCE, MPL3115_I2C_ADDRESS) < 0) { |
| 742 |
ERROR("barometer: MPL3115_detect problem setting i2c slave address to " |
| 743 |
"0x%02X: %s", |
| 744 |
MPL3115_I2C_ADDRESS, STRERRNO); |
| 745 |
return 0; |
| 746 |
} |
| 747 |
|
| 748 |
res = i2c_smbus_read_byte_data(i2c_bus_fd, MPL3115_REG_WHO_AM_I); |
| 749 |
if (res == MPL3115_WHO_AM_I_RESP) { |
| 750 |
DEBUG("barometer: MPL3115_detect - positive detection"); |
| 751 |
return 1; |
| 752 |
} |
| 753 |
|
| 754 |
DEBUG("barometer: MPL3115_detect - negative detection"); |
| 755 |
return 0; |
| 756 |
} |
| 757 |
|
| 758 |
/** |
| 759 |
* Adjusts oversampling to values supported by MPL3115 |
| 760 |
* |
| 761 |
* MPL3115 supports only power of 2 in the range 1 to 128. |
| 762 |
*/ |
| 763 |
static void MPL3115_adjust_oversampling(void) { |
| 764 |
int new_val = 0; |
| 765 |
|
| 766 |
if (config_oversample > 100) { |
| 767 |
new_val = 128; |
| 768 |
mpl3115_oversample = MPL3115_CTRL_REG1_OST_128; |
| 769 |
} else if (config_oversample > 48) { |
| 770 |
new_val = 64; |
| 771 |
mpl3115_oversample = MPL3115_CTRL_REG1_OST_64; |
| 772 |
} else if (config_oversample > 24) { |
| 773 |
new_val = 32; |
| 774 |
mpl3115_oversample = MPL3115_CTRL_REG1_OST_32; |
| 775 |
} else if (config_oversample > 12) { |
| 776 |
new_val = 16; |
| 777 |
mpl3115_oversample = MPL3115_CTRL_REG1_OST_16; |
| 778 |
} else if (config_oversample > 6) { |
| 779 |
new_val = 8; |
| 780 |
mpl3115_oversample = MPL3115_CTRL_REG1_OST_8; |
| 781 |
} else if (config_oversample > 3) { |
| 782 |
new_val = 4; |
| 783 |
mpl3115_oversample = MPL3115_CTRL_REG1_OST_4; |
| 784 |
} else if (config_oversample > 1) { |
| 785 |
new_val = 2; |
| 786 |
mpl3115_oversample = MPL3115_CTRL_REG1_OST_2; |
| 787 |
} else { |
| 788 |
new_val = 1; |
| 789 |
mpl3115_oversample = MPL3115_CTRL_REG1_OST_1; |
| 790 |
} |
| 791 |
|
| 792 |
DEBUG("barometer: MPL3115_adjust_oversampling - correcting oversampling from " |
| 793 |
"%d to %d", |
| 794 |
config_oversample, new_val); |
| 795 |
config_oversample = new_val; |
| 796 |
} |
| 797 |
|
| 798 |
/** |
| 799 |
* Read sensor averaged measurements |
| 800 |
* |
| 801 |
* @param pressure averaged measured pressure |
| 802 |
* @param temperature averaged measured temperature |
| 803 |
* |
| 804 |
* @return Zero when successful |
| 805 |
*/ |
| 806 |
static int MPL3115_read(double *pressure, double *temperature) { |
| 807 |
__s32 res; |
| 808 |
__s32 ctrl; |
| 809 |
__u8 data[MPL3115_NUM_CONV_VALS]; |
| 810 |
long int tmp_value = 0; |
| 811 |
|
| 812 |
/* Set Active - activate the device from standby */ |
| 813 |
res = i2c_smbus_read_byte_data(i2c_bus_fd, MPL3115_REG_CTRL_REG1); |
| 814 |
if (res < 0) { |
| 815 |
ERROR("barometer: MPL3115_read - cannot read CTRL_REG1: %s", STRERRNO); |
| 816 |
return 1; |
| 817 |
} |
| 818 |
ctrl = res; |
| 819 |
res = i2c_smbus_write_byte_data(i2c_bus_fd, MPL3115_REG_CTRL_REG1, |
| 820 |
ctrl | MPL3115_CTRL_REG1_SBYB); |
| 821 |
if (res < 0) { |
| 822 |
ERROR("barometer: MPL3115_read - problem activating: %s", STRERRNO); |
| 823 |
return 1; |
| 824 |
} |
| 825 |
|
| 826 |
/* base sleep is 5ms x OST */ |
| 827 |
usleep(5000 * config_oversample); |
| 828 |
|
| 829 |
/* check the flags/status if ready */ |
| 830 |
res = i2c_smbus_read_byte_data(i2c_bus_fd, MPL3115_REG_STATUS); |
| 831 |
if (res < 0) { |
| 832 |
ERROR("barometer: MPL3115_read - cannot read status register: %s", |
| 833 |
STRERRNO); |
| 834 |
return 1; |
| 835 |
} |
| 836 |
|
| 837 |
while ((res & MPL3115_DR_STATUS_DR) != MPL3115_DR_STATUS_DR) { |
| 838 |
/* try some extra sleep... */ |
| 839 |
usleep(10000); |
| 840 |
|
| 841 |
/* ... and repeat the check. The conversion has to finish sooner or later. |
| 842 |
*/ |
| 843 |
res = i2c_smbus_read_byte_data(i2c_bus_fd, MPL3115_REG_STATUS); |
| 844 |
if (res < 0) { |
| 845 |
ERROR("barometer: MPL3115_read - cannot read status register: %s", |
| 846 |
STRERRNO); |
| 847 |
return 1; |
| 848 |
} |
| 849 |
} |
| 850 |
|
| 851 |
/* Now read all the data in one block. There is address autoincrement. */ |
| 852 |
res = i2c_smbus_read_i2c_block_data(i2c_bus_fd, MPL3115_REG_OUT_P_MSB, |
| 853 |
MPL3115_NUM_CONV_VALS, data); |
| 854 |
if (res < 0) { |
| 855 |
ERROR("barometer: MPL3115_read - cannot read data registers: %s", STRERRNO); |
| 856 |
return 1; |
| 857 |
} |
| 858 |
|
| 859 |
tmp_value = (data[0] << 16) | (data[1] << 8) | data[2]; |
| 860 |
*pressure = ((double)tmp_value) / 4.0 / 16.0 / 100.0; |
| 861 |
DEBUG("barometer: MPL3115_read - absolute pressure = %lf hPa", *pressure); |
| 862 |
|
| 863 |
if (data[3] > 0x7F) { |
| 864 |
data[3] = ~data[3] + 1; |
| 865 |
*temperature = data[3]; |
| 866 |
*temperature = -*temperature; |
| 867 |
} else { |
| 868 |
*temperature = data[3]; |
| 869 |
} |
| 870 |
|
| 871 |
*temperature += (double)(data[4]) / 256.0; |
| 872 |
DEBUG("barometer: MPL3115_read - temperature = %lf C", *temperature); |
| 873 |
|
| 874 |
return 0; |
| 875 |
} |
| 876 |
|
| 877 |
/** |
| 878 |
* Initialize MPL3115 for barometeric measurements |
| 879 |
* |
| 880 |
* @return 0 if successful |
| 881 |
*/ |
| 882 |
static int MPL3115_init_sensor(void) { |
| 883 |
__s32 res; |
| 884 |
__s8 offset; |
| 885 |
|
| 886 |
/* Reset the sensor. It will reset immediately without ACKing */ |
| 887 |
/* the transaction, so no error handling here. */ |
| 888 |
i2c_smbus_write_byte_data(i2c_bus_fd, MPL3115_REG_CTRL_REG1, |
| 889 |
MPL3115_CTRL_REG1_RST); |
| 890 |
|
| 891 |
/* wait some time for the reset to finish */ |
| 892 |
usleep(100000); |
| 893 |
|
| 894 |
/* now it should be in standby already so we can go and configure it */ |
| 895 |
|
| 896 |
/* Set temperature offset. */ |
| 897 |
/* result = ADCtemp + offset [C] */ |
| 898 |
offset = (__s8)(config_temp_offset * 16.0); |
| 899 |
res = i2c_smbus_write_byte_data(i2c_bus_fd, MPL3115_REG_OFF_T, offset); |
| 900 |
if (res < 0) { |
| 901 |
ERROR("barometer: MPL3115_init_sensor - problem setting temp offset: %s", |
| 902 |
STRERRNO); |
| 903 |
return -1; |
| 904 |
} |
| 905 |
|
| 906 |
/* Set pressure offset. */ |
| 907 |
/* result = ADCpress + offset [hPa] */ |
| 908 |
offset = (__s8)(config_press_offset * 100.0 / 4.0); |
| 909 |
res = i2c_smbus_write_byte_data(i2c_bus_fd, MPL3115_REG_OFF_P, offset); |
| 910 |
if (res < 0) { |
| 911 |
ERROR( |
| 912 |
"barometer: MPL3115_init_sensor - problem setting pressure offset: %s", |
| 913 |
STRERRNO); |
| 914 |
return -1; |
| 915 |
} |
| 916 |
|
| 917 |
/* Enable Data Flags in PT_DATA_CFG - flags on both pressure and temp */ |
| 918 |
res = i2c_smbus_write_byte_data(i2c_bus_fd, MPL3115_REG_PT_DATA_CFG, |
| 919 |
MPL3115_PT_DATA_DREM | MPL3115_PT_DATA_PDEF | |
| 920 |
MPL3115_PT_DATA_TDEF); |
| 921 |
if (res < 0) { |
| 922 |
ERROR("barometer: MPL3115_init_sensor - problem setting PT_DATA_CFG: %s", |
| 923 |
STRERRNO); |
| 924 |
return -1; |
| 925 |
} |
| 926 |
|
| 927 |
/* Set to barometer with an OSR */ |
| 928 |
res = i2c_smbus_write_byte_data(i2c_bus_fd, MPL3115_REG_CTRL_REG1, |
| 929 |
mpl3115_oversample); |
| 930 |
if (res < 0) { |
| 931 |
ERROR("barometer: MPL3115_init_sensor - problem configuring CTRL_REG1: %s", |
| 932 |
STRERRNO); |
| 933 |
return -1; |
| 934 |
} |
| 935 |
|
| 936 |
return 0; |
| 937 |
} |
| 938 |
|
| 939 |
/* ------------------------ BMP085 access ------------------------ */ |
| 940 |
|
| 941 |
/** |
| 942 |
* Detect presence of a BMP085 pressure sensor by checking its ID register |
| 943 |
* |
| 944 |
* As a sideeffect will leave set I2C slave address. |
| 945 |
* |
| 946 |
* @return 1 if BMP085, 0 otherwise |
| 947 |
*/ |
| 948 |
static int BMP085_detect(void) { |
| 949 |
__s32 res; |
| 950 |
|
| 951 |
if (ioctl(i2c_bus_fd, I2C_SLAVE_FORCE, BMP085_I2C_ADDRESS) < 0) { |
| 952 |
ERROR("barometer: BMP085_detect - problem setting i2c slave address to " |
| 953 |
"0x%02X: %s", |
| 954 |
BMP085_I2C_ADDRESS, STRERRNO); |
| 955 |
return 0; |
| 956 |
} |
| 957 |
|
| 958 |
res = i2c_smbus_read_byte_data(i2c_bus_fd, BMP085_ADDR_ID_REG); |
| 959 |
if (res == BMP085_CHIP_ID) { |
| 960 |
DEBUG("barometer: BMP085_detect - positive detection"); |
| 961 |
|
| 962 |
/* get version */ |
| 963 |
res = i2c_smbus_read_byte_data(i2c_bus_fd, BMP085_ADDR_VERSION); |
| 964 |
if (res < 0) { |
| 965 |
ERROR("barometer: BMP085_detect - problem checking chip version: %s", |
| 966 |
STRERRNO); |
| 967 |
return 0; |
| 968 |
} |
| 969 |
DEBUG("barometer: BMP085_detect - chip version ML:0x%02X AL:0x%02X", |
| 970 |
res & 0x0f, (res & 0xf0) >> 4); |
| 971 |
return 1; |
| 972 |
} |
| 973 |
|
| 974 |
DEBUG("barometer: BMP085_detect - negative detection"); |
| 975 |
return 0; |
| 976 |
} |
| 977 |
|
| 978 |
/** |
| 979 |
* Adjusts oversampling settings to values supported by BMP085 |
| 980 |
* |
| 981 |
* BMP085 supports only 1,2,4 or 8 samples. |
| 982 |
*/ |
| 983 |
static void BMP085_adjust_oversampling(void) { |
| 984 |
int new_val = 0; |
| 985 |
|
| 986 |
if (config_oversample > 6) /* 8 */ |
| 987 |
{ |
| 988 |
new_val = 8; |
| 989 |
bmp085_oversampling = 3; |
| 990 |
bmp085_cmdCnvPress = BMP085_CMD_CONVERT_PRESS_3; |
| 991 |
bmp085_timeCnvPress = BMP085_TIME_CNV_PRESS_3; |
| 992 |
} else if (config_oversample > 3) /* 4 */ |
| 993 |
{ |
| 994 |
new_val = 4; |
| 995 |
bmp085_oversampling = 2; |
| 996 |
bmp085_cmdCnvPress = BMP085_CMD_CONVERT_PRESS_2; |
| 997 |
bmp085_timeCnvPress = BMP085_TIME_CNV_PRESS_2; |
| 998 |
} else if (config_oversample > 1) /* 2 */ |
| 999 |
{ |
| 1000 |
new_val = 2; |
| 1001 |
bmp085_oversampling = 1; |
| 1002 |
bmp085_cmdCnvPress = BMP085_CMD_CONVERT_PRESS_1; |
| 1003 |
bmp085_timeCnvPress = BMP085_TIME_CNV_PRESS_1; |
| 1004 |
} else /* 1 */ |
| 1005 |
{ |
| 1006 |
new_val = 1; |
| 1007 |
bmp085_oversampling = 0; |
| 1008 |
bmp085_cmdCnvPress = BMP085_CMD_CONVERT_PRESS_0; |
| 1009 |
bmp085_timeCnvPress = BMP085_TIME_CNV_PRESS_0; |
| 1010 |
} |
| 1011 |
|
| 1012 |
DEBUG("barometer: BMP085_adjust_oversampling - correcting oversampling from " |
| 1013 |
"%d to %d", |
| 1014 |
config_oversample, new_val); |
| 1015 |
config_oversample = new_val; |
| 1016 |
} |
| 1017 |
|
| 1018 |
/** |
| 1019 |
* Read the BMP085 sensor conversion coefficients. |
| 1020 |
* |
| 1021 |
* These are (device specific) constants so we can read them just once. |
| 1022 |
* |
| 1023 |
* @return Zero when successful |
| 1024 |
*/ |
| 1025 |
static int BMP085_read_coeffs(void) { |
| 1026 |
__s32 res; |
| 1027 |
__u8 coeffs[BMP085_NUM_COEFFS]; |
| 1028 |
|
| 1029 |
res = i2c_smbus_read_i2c_block_data(i2c_bus_fd, BMP085_ADDR_COEFFS, |
| 1030 |
BMP085_NUM_COEFFS, coeffs); |
| 1031 |
if (res < 0) { |
| 1032 |
ERROR("barometer: BMP085_read_coeffs - problem reading data: %s", STRERRNO); |
| 1033 |
return -1; |
| 1034 |
} |
| 1035 |
|
| 1036 |
bmp085_AC1 = ((int16_t)coeffs[0] << 8) | (int16_t)coeffs[1]; |
| 1037 |
bmp085_AC2 = ((int16_t)coeffs[2] << 8) | (int16_t)coeffs[3]; |
| 1038 |
bmp085_AC3 = ((int16_t)coeffs[4] << 8) | (int16_t)coeffs[5]; |
| 1039 |
bmp085_AC4 = ((uint16_t)coeffs[6] << 8) | (uint16_t)coeffs[7]; |
| 1040 |
bmp085_AC5 = ((uint16_t)coeffs[8] << 8) | (uint16_t)coeffs[9]; |
| 1041 |
bmp085_AC6 = ((uint16_t)coeffs[10] << 8) | (uint16_t)coeffs[11]; |
| 1042 |
bmp085_B1 = ((int16_t)coeffs[12] << 8) | (int16_t)coeffs[13]; |
| 1043 |
bmp085_B2 = ((int16_t)coeffs[14] << 8) | (int16_t)coeffs[15]; |
| 1044 |
bmp085_MB = ((int16_t)coeffs[16] << 8) | (int16_t)coeffs[17]; |
| 1045 |
bmp085_MC = ((int16_t)coeffs[18] << 8) | (int16_t)coeffs[19]; |
| 1046 |
bmp085_MD = ((int16_t)coeffs[20] << 8) | (int16_t)coeffs[21]; |
| 1047 |
|
| 1048 |
DEBUG("barometer: BMP085_read_coeffs - AC1=%d, AC2=%d, AC3=%d, AC4=%u," |
| 1049 |
" AC5=%u, AC6=%u, B1=%d, B2=%d, MB=%d, MC=%d, MD=%d", |
| 1050 |
bmp085_AC1, bmp085_AC2, bmp085_AC3, bmp085_AC4, bmp085_AC5, bmp085_AC6, |
| 1051 |
bmp085_B1, bmp085_B2, bmp085_MB, bmp085_MC, bmp085_MD); |
| 1052 |
|
| 1053 |
return 0; |
| 1054 |
} |
| 1055 |
|
| 1056 |
/** |
| 1057 |
* Convert raw BMP085 adc values to real data using the sensor coefficients. |
| 1058 |
* |
| 1059 |
* @param adc_pressure adc pressure value to be converted |
| 1060 |
* @param adc_temp adc temperature value to be converted |
| 1061 |
* @param pressure computed real pressure |
| 1062 |
* @param temperature computed real temperature |
| 1063 |
*/ |
| 1064 |
static void BMP085_convert_adc_to_real(long adc_pressure, long adc_temperature, |
| 1065 |
double *pressure, double *temperature) |
| 1066 |
|
| 1067 |
{ |
| 1068 |
long X1, X2, X3; |
| 1069 |
long B3, B5, B6; |
| 1070 |
unsigned long B4, B7; |
| 1071 |
|
| 1072 |
long T; |
| 1073 |
long P; |
| 1074 |
|
| 1075 |
/* calculate real temperature */ |
| 1076 |
X1 = ((adc_temperature - bmp085_AC6) * bmp085_AC5) >> 15; |
| 1077 |
X2 = (bmp085_MC << 11) / (X1 + bmp085_MD); |
| 1078 |
|
| 1079 |
/* B5, T */ |
| 1080 |
B5 = X1 + X2; |
| 1081 |
T = (B5 + 8) >> 4; |
| 1082 |
*temperature = (double)T * 0.1; |
| 1083 |
|
| 1084 |
/* calculate real pressure */ |
| 1085 |
/* in general X1, X2, X3 are recycled while values of B3, B4, B5, B6 are kept |
| 1086 |
*/ |
| 1087 |
|
| 1088 |
/* B6, B3 */ |
| 1089 |
B6 = B5 - 4000; |
| 1090 |
X1 = ((bmp085_B2 * ((B6 * B6) >> 12)) >> 11); |
| 1091 |
X2 = (((long)bmp085_AC2 * B6) >> 11); |
| 1092 |
X3 = X1 + X2; |
| 1093 |
B3 = (((((long)bmp085_AC1 * 4) + X3) << bmp085_oversampling) + 2) >> 2; |
| 1094 |
|
| 1095 |
/* B4 */ |
| 1096 |
X1 = (((long)bmp085_AC3 * B6) >> 13); |
| 1097 |
X2 = (bmp085_B1 * ((B6 * B6) >> 12)) >> 16; |
| 1098 |
X3 = ((X1 + X2) + 2) >> 2; |
| 1099 |
B4 = ((long)bmp085_AC4 * (unsigned long)(X3 + 32768)) >> 15; |
| 1100 |
|
| 1101 |
/* B7, P */ |
| 1102 |
B7 = (unsigned long)(adc_pressure - B3) * (50000 >> bmp085_oversampling); |
| 1103 |
if (B7 < 0x80000000) { |
| 1104 |
P = (B7 << 1) / B4; |
| 1105 |
} else { |
| 1106 |
P = (B7 / B4) << 1; |
| 1107 |
} |
| 1108 |
X1 = (P >> 8) * (P >> 8); |
| 1109 |
X1 = (X1 * 3038) >> 16; |
| 1110 |
X2 = ((-7357) * P) >> 16; |
| 1111 |
P = P + ((X1 + X2 + 3791) >> 4); |
| 1112 |
|
| 1113 |
*pressure = P / 100.0; // in [hPa] |
| 1114 |
DEBUG("barometer: BMP085_convert_adc_to_real - got %lf hPa, %lf C", *pressure, |
| 1115 |
*temperature); |
| 1116 |
} |
| 1117 |
|
| 1118 |
/** |
| 1119 |
* Read compensated sensor measurements |
| 1120 |
* |
| 1121 |
* @param pressure averaged measured pressure |
| 1122 |
* @param temperature averaged measured temperature |
| 1123 |
* |
| 1124 |
* @return Zero when successful |
| 1125 |
*/ |
| 1126 |
static int BMP085_read(double *pressure, double *temperature) { |
| 1127 |
__s32 res; |
| 1128 |
__u8 measBuff[3]; |
| 1129 |
|
| 1130 |
long adc_pressure; |
| 1131 |
long adc_temperature; |
| 1132 |
|
| 1133 |
/* start conversion of temperature */ |
| 1134 |
res = i2c_smbus_write_byte_data(i2c_bus_fd, BMP085_ADDR_CTRL_REG, |
| 1135 |
BMP085_CMD_CONVERT_TEMP); |
| 1136 |
if (res < 0) { |
| 1137 |
ERROR("barometer: BMP085_read - problem requesting temperature conversion: " |
| 1138 |
"%s", |
| 1139 |
STRERRNO); |
| 1140 |
return 1; |
| 1141 |
} |
| 1142 |
|
| 1143 |
usleep(BMP085_TIME_CNV_TEMP); /* wait for the conversion */ |
| 1144 |
|
| 1145 |
res = |
| 1146 |
i2c_smbus_read_i2c_block_data(i2c_bus_fd, BMP085_ADDR_CONV, 2, measBuff); |
| 1147 |
if (res < 0) { |
| 1148 |
ERROR("barometer: BMP085_read - problem reading temperature data: %s", |
| 1149 |
STRERRNO); |
| 1150 |
return 1; |
| 1151 |
} |
| 1152 |
|
| 1153 |
adc_temperature = ((unsigned short)measBuff[0] << 8) + measBuff[1]; |
| 1154 |
|
| 1155 |
/* get presure */ |
| 1156 |
res = i2c_smbus_write_byte_data(i2c_bus_fd, BMP085_ADDR_CTRL_REG, |
| 1157 |
bmp085_cmdCnvPress); |
| 1158 |
if (res < 0) { |
| 1159 |
ERROR("barometer: BMP085_read - problem requesting pressure conversion: %s", |
| 1160 |
STRERRNO); |
| 1161 |
return 1; |
| 1162 |
} |
| 1163 |
|
| 1164 |
usleep(bmp085_timeCnvPress); /* wait for the conversion */ |
| 1165 |
|
| 1166 |
res = |
| 1167 |
i2c_smbus_read_i2c_block_data(i2c_bus_fd, BMP085_ADDR_CONV, 3, measBuff); |
| 1168 |
if (res < 0) { |
| 1169 |
ERROR("barometer: BMP085_read - problem reading pressure data: %s", |
| 1170 |
STRERRNO); |
| 1171 |
return 1; |
| 1172 |
} |
| 1173 |
|
| 1174 |
adc_pressure = (long)((((ulong)measBuff[0] << 16) | |
| 1175 |
((ulong)measBuff[1] << 8) | (ulong)measBuff[2]) >> |
| 1176 |
(8 - bmp085_oversampling)); |
| 1177 |
|
| 1178 |
DEBUG("barometer: BMP085_read - raw pressure ADC value = %ld, " |
| 1179 |
"raw temperature ADC value = %ld", |
| 1180 |
adc_pressure, adc_temperature); |
| 1181 |
|
| 1182 |
BMP085_convert_adc_to_real(adc_pressure, adc_temperature, pressure, |
| 1183 |
temperature); |
| 1184 |
|
| 1185 |
return 0; |
| 1186 |
} |
| 1187 |
|
| 1188 |
/* ------------------------ Sensor detection ------------------------ */ |
| 1189 |
/** |
| 1190 |
* Detect presence of a supported sensor. |
| 1191 |
* |
| 1192 |
* As a sideeffect will leave set I2C slave address. |
| 1193 |
* The detection is done in the order BMP085, MPL3115, MPL115 and stops after |
| 1194 |
* first sensor beeing found. |
| 1195 |
* |
| 1196 |
* @return detected sensor type |
| 1197 |
*/ |
| 1198 |
static enum Sensor_type detect_sensor_type(void) { |
| 1199 |
if (BMP085_detect()) |
| 1200 |
return Sensor_BMP085; |
| 1201 |
|
| 1202 |
else if (MPL3115_detect()) |
| 1203 |
return Sensor_MPL3115; |
| 1204 |
|
| 1205 |
else if (MPL115_detect()) |
| 1206 |
return Sensor_MPL115; |
| 1207 |
|
| 1208 |
return Sensor_none; |
| 1209 |
} |
| 1210 |
|
| 1211 |
/* ------------------------ Common functionality ------------------------ */ |
| 1212 |
|
| 1213 |
/** |
| 1214 |
* Convert absolute pressure (in hPa) to mean sea level pressure |
| 1215 |
* |
| 1216 |
* Implemented methods are: |
| 1217 |
* - MSLP_NONE - no converions, returns absolute pressure |
| 1218 |
* |
| 1219 |
* - MSLP_INTERNATIONAL - see |
| 1220 |
* http://en.wikipedia.org/wiki/Atmospheric_pressure#Altitude_atmospheric_pressure_variation |
| 1221 |
* Requires #config_altitude |
| 1222 |
* |
| 1223 |
* - MSLP_DEU_WETT - formula as recommended by the Deutsche Wetterdienst. See |
| 1224 |
* http://de.wikipedia.org/wiki/Barometrische_H%C3%B6henformel#Theorie |
| 1225 |
* Requires both #config_altitude and temperature reference(s). |
| 1226 |
* |
| 1227 |
* @param abs_pressure absloute pressure to be converted |
| 1228 |
* |
| 1229 |
* @return mean sea level pressure if successful, NAN otherwise |
| 1230 |
*/ |
| 1231 |
static double abs_to_mean_sea_level_pressure(double abs_pressure) { |
| 1232 |
double mean = -1.0; |
| 1233 |
double temp = 0.0; |
| 1234 |
int result = 0; |
| 1235 |
|
| 1236 |
if (config_normalize >= MSLP_DEU_WETT) { |
| 1237 |
result = get_reference_temperature(&temp); |
| 1238 |
if (result) { |
| 1239 |
return NAN; |
| 1240 |
} |
| 1241 |
} |
| 1242 |
|
| 1243 |
switch (config_normalize) { |
| 1244 |
case MSLP_NONE: |
| 1245 |
mean = abs_pressure; |
| 1246 |
break; |
| 1247 |
|
| 1248 |
case MSLP_INTERNATIONAL: |
| 1249 |
mean = abs_pressure / pow(1.0 - 0.0065 * config_altitude / 288.15, |
| 1250 |
9.80665 * 0.0289644 / (8.31447 * 0.0065)); |
| 1251 |
break; |
| 1252 |
|
| 1253 |
case MSLP_DEU_WETT: { |
| 1254 |
double E; /* humidity */ |
| 1255 |
double x; |
| 1256 |
if (temp < 9.1) |
| 1257 |
E = 5.6402 * (-0.0916 + exp(0.06 * temp)); |
| 1258 |
else |
| 1259 |
E = 18.2194 * (1.0463 - exp(-0.0666 * temp)); |
| 1260 |
x = 9.80665 / |
| 1261 |
(287.05 * (temp + 273.15 + 0.12 * E + 0.0065 * config_altitude / 2)) * |
| 1262 |
config_altitude; |
| 1263 |
mean = abs_pressure * exp(x); |
| 1264 |
} break; |
| 1265 |
|
| 1266 |
default: |
| 1267 |
ERROR( |
| 1268 |
"barometer: abs_to_mean_sea_level_pressure: wrong conversion method %d", |
| 1269 |
config_normalize); |
| 1270 |
mean = abs_pressure; |
| 1271 |
break; |
| 1272 |
} |
| 1273 |
|
| 1274 |
DEBUG("barometer: abs_to_mean_sea_level_pressure: absPressure = %lf hPa, " |
| 1275 |
"method = %d, meanPressure = %lf hPa", |
| 1276 |
abs_pressure, config_normalize, mean); |
| 1277 |
|
| 1278 |
return mean; |
| 1279 |
} |
| 1280 |
|
| 1281 |
/* ------------------------ main plugin callbacks ------------------------ */ |
| 1282 |
|
| 1283 |
/** |
| 1284 |
* Main plugin configuration callback (using simple config) |
| 1285 |
* |
| 1286 |
* @param key configuration key we should process |
| 1287 |
* @param value configuration value we should process |
| 1288 |
* |
| 1289 |
* @return Zero when successful. |
| 1290 |
*/ |
| 1291 |
static int collectd_barometer_config(const char *key, const char *value) { |
| 1292 |
DEBUG("barometer: collectd_barometer_config"); |
| 1293 |
|
| 1294 |
if (strcasecmp(key, "Device") == 0) { |
| 1295 |
sfree(config_device); |
| 1296 |
config_device = strdup(value); |
| 1297 |
} else if (strcasecmp(key, "Oversampling") == 0) { |
| 1298 |
int oversampling_tmp = atoi(value); |
| 1299 |
if (oversampling_tmp < 1 || oversampling_tmp > 1024) { |
| 1300 |
WARNING("barometer: collectd_barometer_config: invalid oversampling: %d." |
| 1301 |
" Allowed values are 1 to 1024 (for MPL115) or 1 to 128 (for " |
| 1302 |
"MPL3115) or 1 to 8 (for BMP085).", |
| 1303 |
oversampling_tmp); |
| 1304 |
return 1; |
| 1305 |
} |
| 1306 |
config_oversample = oversampling_tmp; |
| 1307 |
} else if (strcasecmp(key, "Altitude") == 0) { |
| 1308 |
config_altitude = atof(value); |
| 1309 |
} else if (strcasecmp(key, "Normalization") == 0) { |
| 1310 |
int normalize_tmp = atoi(value); |
| 1311 |
if (normalize_tmp < 0 || normalize_tmp > 2) { |
| 1312 |
ERROR("barometer: collectd_barometer_config: invalid normalization: %d", |
| 1313 |
normalize_tmp); |
| 1314 |
return 1; |
| 1315 |
} |
| 1316 |
config_normalize = normalize_tmp; |
| 1317 |
} else if (strcasecmp(key, "TemperatureSensor") == 0) { |
| 1318 |
if (temp_list_add(temp_list, value)) { |
| 1319 |
return -1; |
| 1320 |
} |
| 1321 |
} else if (strcasecmp(key, "PressureOffset") == 0) { |
| 1322 |
config_press_offset = atof(value); |
| 1323 |
} else if (strcasecmp(key, "TemperatureOffset") == 0) { |
| 1324 |
config_temp_offset = atof(value); |
| 1325 |
} else { |
| 1326 |
return -1; |
| 1327 |
} |
| 1328 |
|
| 1329 |
return 0; |
| 1330 |
} |
| 1331 |
|
| 1332 |
/** |
| 1333 |
* Shutdown callback. |
| 1334 |
* |
| 1335 |
* Close I2C and delete all the buffers. |
| 1336 |
* |
| 1337 |
* @return Zero when successful (at the moment the only possible outcome) |
| 1338 |
*/ |
| 1339 |
static int collectd_barometer_shutdown(void) { |
| 1340 |
DEBUG("barometer: collectd_barometer_shutdown"); |
| 1341 |
|
| 1342 |
if (sensor_type == Sensor_MPL115) { |
| 1343 |
averaging_delete(&pressure_averaging); |
| 1344 |
averaging_delete(&temperature_averaging); |
| 1345 |
|
| 1346 |
temp_list_delete(&temp_list); |
| 1347 |
} |
| 1348 |
|
| 1349 |
if (i2c_bus_fd > 0) { |
| 1350 |
close(i2c_bus_fd); |
| 1351 |
i2c_bus_fd = -1; |
| 1352 |
sfree(config_device); |
| 1353 |
} |
| 1354 |
|
| 1355 |
return 0; |
| 1356 |
} |
| 1357 |
|
| 1358 |
/** |
| 1359 |
* Plugin read callback for MPL115. |
| 1360 |
* |
| 1361 |
* Dispatching will create values: |
| 1362 |
* - <hostname>/barometer-mpl115/pressure-normalized |
| 1363 |
* - <hostname>/barometer-mpl115/pressure-absolute |
| 1364 |
* - <hostname>/barometer-mpl115/temperature |
| 1365 |
* |
| 1366 |
* @return Zero when successful. |
| 1367 |
*/ |
| 1368 |
static int MPL115_collectd_barometer_read(void) { |
| 1369 |
int result = 0; |
| 1370 |
|
| 1371 |
double pressure = 0.0; |
| 1372 |
double temperature = 0.0; |
| 1373 |
double norm_pressure = 0.0; |
| 1374 |
|
| 1375 |
value_list_t vl = VALUE_LIST_INIT; |
| 1376 |
value_t values[1]; |
| 1377 |
|
| 1378 |
DEBUG("barometer: MPL115_collectd_barometer_read"); |
| 1379 |
|
| 1380 |
if (!configured) { |
| 1381 |
return -1; |
| 1382 |
} |
| 1383 |
|
| 1384 |
/* Rather than delaying init, we will intitialize during first read. This |
| 1385 |
way at least we have a better chance to have the reference temperature |
| 1386 |
already available. */ |
| 1387 |
if (!avg_initialized) { |
| 1388 |
for (int i = 0; i < config_oversample - 1; ++i) { |
| 1389 |
result = MPL115_read_averaged(&pressure, &temperature); |
| 1390 |
if (result) { |
| 1391 |
ERROR("barometer: MPL115_collectd_barometer_read - mpl115 read, " |
| 1392 |
"ignored during init"); |
| 1393 |
} |
| 1394 |
DEBUG("barometer: MPL115_collectd_barometer_read - init %d / %d", i + 1, |
| 1395 |
config_oversample - 1); |
| 1396 |
usleep(20000); |
| 1397 |
} |
| 1398 |
avg_initialized = true; |
| 1399 |
} |
| 1400 |
|
| 1401 |
result = MPL115_read_averaged(&pressure, &temperature); |
| 1402 |
if (result) |
| 1403 |
return result; |
| 1404 |
|
| 1405 |
norm_pressure = abs_to_mean_sea_level_pressure(pressure); |
| 1406 |
|
| 1407 |
sstrncpy(vl.plugin, "barometer", sizeof(vl.plugin)); |
| 1408 |
sstrncpy(vl.plugin_instance, "mpl115", sizeof(vl.plugin_instance)); |
| 1409 |
|
| 1410 |
vl.values_len = 1; |
| 1411 |
vl.values = values; |
| 1412 |
|
| 1413 |
/* dispatch normalized air pressure */ |
| 1414 |
sstrncpy(vl.type, "pressure", sizeof(vl.type)); |
| 1415 |
sstrncpy(vl.type_instance, "normalized", sizeof(vl.type_instance)); |
| 1416 |
values[0].gauge = norm_pressure; |
| 1417 |
plugin_dispatch_values(&vl); |
| 1418 |
|
| 1419 |
/* dispatch absolute air pressure */ |
| 1420 |
sstrncpy(vl.type, "pressure", sizeof(vl.type)); |
| 1421 |
sstrncpy(vl.type_instance, "absolute", sizeof(vl.type_instance)); |
| 1422 |
values[0].gauge = pressure; |
| 1423 |
plugin_dispatch_values(&vl); |
| 1424 |
|
| 1425 |
/* dispatch sensor temperature */ |
| 1426 |
sstrncpy(vl.type, "temperature", sizeof(vl.type)); |
| 1427 |
sstrncpy(vl.type_instance, "", sizeof(vl.type_instance)); |
| 1428 |
values[0].gauge = temperature; |
| 1429 |
plugin_dispatch_values(&vl); |
| 1430 |
|
| 1431 |
return 0; |
| 1432 |
} |
| 1433 |
|
| 1434 |
/** |
| 1435 |
* Plugin read callback for MPL3115. |
| 1436 |
* |
| 1437 |
* Dispatching will create values: |
| 1438 |
* - <hostname>/barometer-mpl3115/pressure-normalized |
| 1439 |
* - <hostname>/barometer-mpl3115/pressure-absolute |
| 1440 |
* - <hostname>/barometer-mpl3115/temperature |
| 1441 |
* |
| 1442 |
* @return Zero when successful. |
| 1443 |
*/ |
| 1444 |
static int MPL3115_collectd_barometer_read(void) { |
| 1445 |
int result = 0; |
| 1446 |
|
| 1447 |
double pressure = 0.0; |
| 1448 |
double temperature = 0.0; |
| 1449 |
double norm_pressure = 0.0; |
| 1450 |
|
| 1451 |
value_list_t vl = VALUE_LIST_INIT; |
| 1452 |
value_t values[1]; |
| 1453 |
|
| 1454 |
DEBUG("barometer: MPL3115_collectd_barometer_read"); |
| 1455 |
|
| 1456 |
if (!configured) { |
| 1457 |
return -1; |
| 1458 |
} |
| 1459 |
|
| 1460 |
result = MPL3115_read(&pressure, &temperature); |
| 1461 |
if (result) |
| 1462 |
return result; |
| 1463 |
|
| 1464 |
norm_pressure = abs_to_mean_sea_level_pressure(pressure); |
| 1465 |
|
| 1466 |
sstrncpy(vl.plugin, "barometer", sizeof(vl.plugin)); |
| 1467 |
sstrncpy(vl.plugin_instance, "mpl3115", sizeof(vl.plugin_instance)); |
| 1468 |
|
| 1469 |
vl.values_len = 1; |
| 1470 |
vl.values = values; |
| 1471 |
|
| 1472 |
/* dispatch normalized air pressure */ |
| 1473 |
sstrncpy(vl.type, "pressure", sizeof(vl.type)); |
| 1474 |
sstrncpy(vl.type_instance, "normalized", sizeof(vl.type_instance)); |
| 1475 |
values[0].gauge = norm_pressure; |
| 1476 |
plugin_dispatch_values(&vl); |
| 1477 |
|
| 1478 |
/* dispatch absolute air pressure */ |
| 1479 |
sstrncpy(vl.type, "pressure", sizeof(vl.type)); |
| 1480 |
sstrncpy(vl.type_instance, "absolute", sizeof(vl.type_instance)); |
| 1481 |
values[0].gauge = pressure; |
| 1482 |
plugin_dispatch_values(&vl); |
| 1483 |
|
| 1484 |
/* dispatch sensor temperature */ |
| 1485 |
sstrncpy(vl.type, "temperature", sizeof(vl.type)); |
| 1486 |
sstrncpy(vl.type_instance, "", sizeof(vl.type_instance)); |
| 1487 |
values[0].gauge = temperature; |
| 1488 |
plugin_dispatch_values(&vl); |
| 1489 |
|
| 1490 |
return 0; |
| 1491 |
} |
| 1492 |
|
| 1493 |
/** |
| 1494 |
* Plugin read callback for BMP085. |
| 1495 |
* |
| 1496 |
* Dispatching will create values: |
| 1497 |
* - <hostname>/barometer-bmp085/pressure-normalized |
| 1498 |
* - <hostname>/barometer-bmp085/pressure-absolute |
| 1499 |
* - <hostname>/barometer-bmp085/temperature |
| 1500 |
* |
| 1501 |
* @return Zero when successful. |
| 1502 |
*/ |
| 1503 |
static int BMP085_collectd_barometer_read(void) { |
| 1504 |
int result = 0; |
| 1505 |
|
| 1506 |
double pressure = 0.0; |
| 1507 |
double temperature = 0.0; |
| 1508 |
double norm_pressure = 0.0; |
| 1509 |
|
| 1510 |
value_list_t vl = VALUE_LIST_INIT; |
| 1511 |
value_t values[1]; |
| 1512 |
|
| 1513 |
DEBUG("barometer: BMP085_collectd_barometer_read"); |
| 1514 |
|
| 1515 |
if (!configured) { |
| 1516 |
return -1; |
| 1517 |
} |
| 1518 |
|
| 1519 |
result = BMP085_read(&pressure, &temperature); |
| 1520 |
if (result) |
| 1521 |
return result; |
| 1522 |
|
| 1523 |
norm_pressure = abs_to_mean_sea_level_pressure(pressure); |
| 1524 |
|
| 1525 |
sstrncpy(vl.plugin, "barometer", sizeof(vl.plugin)); |
| 1526 |
sstrncpy(vl.plugin_instance, "bmp085", sizeof(vl.plugin_instance)); |
| 1527 |
|
| 1528 |
vl.values_len = 1; |
| 1529 |
vl.values = values; |
| 1530 |
|
| 1531 |
/* dispatch normalized air pressure */ |
| 1532 |
sstrncpy(vl.type, "pressure", sizeof(vl.type)); |
| 1533 |
sstrncpy(vl.type_instance, "normalized", sizeof(vl.type_instance)); |
| 1534 |
values[0].gauge = norm_pressure; |
| 1535 |
plugin_dispatch_values(&vl); |
| 1536 |
|
| 1537 |
/* dispatch absolute air pressure */ |
| 1538 |
sstrncpy(vl.type, "pressure", sizeof(vl.type)); |
| 1539 |
sstrncpy(vl.type_instance, "absolute", sizeof(vl.type_instance)); |
| 1540 |
values[0].gauge = pressure; |
| 1541 |
plugin_dispatch_values(&vl); |
| 1542 |
|
| 1543 |
/* dispatch sensor temperature */ |
| 1544 |
sstrncpy(vl.type, "temperature", sizeof(vl.type)); |
| 1545 |
sstrncpy(vl.type_instance, "", sizeof(vl.type_instance)); |
| 1546 |
values[0].gauge = temperature; |
| 1547 |
plugin_dispatch_values(&vl); |
| 1548 |
|
| 1549 |
return 0; |
| 1550 |
} |
| 1551 |
|
| 1552 |
/** |
| 1553 |
* Initialization callback |
| 1554 |
* |
| 1555 |
* Check config, initialize I2C bus access, conversion coefficients and |
| 1556 |
* averaging |
| 1557 |
* ring buffers |
| 1558 |
* |
| 1559 |
* @return Zero when successful. |
| 1560 |
*/ |
| 1561 |
static int collectd_barometer_init(void) { |
| 1562 |
|
| 1563 |
DEBUG("barometer: collectd_barometer_init"); |
| 1564 |
|
| 1565 |
if (config_device == NULL) { |
| 1566 |
ERROR("barometer: collectd_barometer_init I2C bus device not configured"); |
| 1567 |
return -1; |
| 1568 |
} |
| 1569 |
|
| 1570 |
if (config_normalize >= MSLP_INTERNATIONAL && isnan(config_altitude)) { |
| 1571 |
ERROR("barometer: collectd_barometer_init no altitude configured " |
| 1572 |
"for mean sea level pressure normalization."); |
| 1573 |
return -1; |
| 1574 |
} |
| 1575 |
|
| 1576 |
if (config_normalize == MSLP_DEU_WETT && temp_list == NULL) { |
| 1577 |
ERROR("barometer: collectd_barometer_init no temperature reference " |
| 1578 |
"configured for mean sea level pressure normalization."); |
| 1579 |
return -1; |
| 1580 |
} |
| 1581 |
|
| 1582 |
i2c_bus_fd = open(config_device, O_RDWR); |
| 1583 |
if (i2c_bus_fd < 0) { |
| 1584 |
ERROR("barometer: collectd_barometer_init problem opening I2C bus device " |
| 1585 |
"\"%s\": %s (is loaded mod i2c-dev?)", |
| 1586 |
config_device, STRERRNO); |
| 1587 |
return -1; |
| 1588 |
} |
| 1589 |
|
| 1590 |
/* detect sensor type - this will also set slave address */ |
| 1591 |
sensor_type = detect_sensor_type(); |
| 1592 |
|
| 1593 |
/* init correct sensor type */ |
| 1594 |
switch (sensor_type) { |
| 1595 |
/* MPL3115 */ |
| 1596 |
case Sensor_MPL3115: { |
| 1597 |
MPL3115_adjust_oversampling(); |
| 1598 |
|
| 1599 |
if (MPL3115_init_sensor()) |
| 1600 |
return -1; |
| 1601 |
|
| 1602 |
plugin_register_read("barometer", MPL3115_collectd_barometer_read); |
| 1603 |
} break; |
| 1604 |
|
| 1605 |
/* MPL115 */ |
| 1606 |
case Sensor_MPL115: { |
| 1607 |
if (averaging_create(&pressure_averaging, config_oversample)) { |
| 1608 |
ERROR( |
| 1609 |
"barometer: collectd_barometer_init pressure averaging init failed"); |
| 1610 |
return -1; |
| 1611 |
} |
| 1612 |
|
| 1613 |
if (averaging_create(&temperature_averaging, config_oversample)) { |
| 1614 |
ERROR("barometer: collectd_barometer_init temperature averaging init " |
| 1615 |
"failed"); |
| 1616 |
return -1; |
| 1617 |
} |
| 1618 |
|
| 1619 |
if (MPL115_read_coeffs() < 0) |
| 1620 |
return -1; |
| 1621 |
|
| 1622 |
plugin_register_read("barometer", MPL115_collectd_barometer_read); |
| 1623 |
} break; |
| 1624 |
|
| 1625 |
/* BMP085 */ |
| 1626 |
case Sensor_BMP085: { |
| 1627 |
BMP085_adjust_oversampling(); |
| 1628 |
|
| 1629 |
if (BMP085_read_coeffs() < 0) |
| 1630 |
return -1; |
| 1631 |
|
| 1632 |
plugin_register_read("barometer", BMP085_collectd_barometer_read); |
| 1633 |
} break; |
| 1634 |
|
| 1635 |
/* anything else -> error */ |
| 1636 |
default: |
| 1637 |
ERROR("barometer: collectd_barometer_init - no supported sensor found"); |
| 1638 |
return -1; |
| 1639 |
} |
| 1640 |
|
| 1641 |
configured = true; |
| 1642 |
return 0; |
| 1643 |
} |
| 1644 |
|
| 1645 |
/* ------------------------ plugin register / entry point |
| 1646 |
* ------------------------ */ |
| 1647 |
|
| 1648 |
/** |
| 1649 |
* Plugin "entry" - register all callback. |
| 1650 |
* |
| 1651 |
*/ |
| 1652 |
void module_register(void) { |
| 1653 |
plugin_register_config("barometer", collectd_barometer_config, config_keys, |
| 1654 |
config_keys_num); |
| 1655 |
plugin_register_init("barometer", collectd_barometer_init); |
| 1656 |
plugin_register_shutdown("barometer", collectd_barometer_shutdown); |
| 1657 |
} |