Subversion Repositories Projects

/*

bmp085 lib 0x01

copyright (c) Davide Gironi, 2012

Released under GPLv3.

Please refer to LICENSE file for licensing information.

*/

//############################################################################

//# HISTORY  bmp085.c

//#

//# 19.09.2015 cebra

//# - add: Library für BMP085/BMP180 Luftdrucksensor, GY-87 Sensorboard

//#

//############################################################################

#ifdef USE_KOMPASS

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include <avr/io.h>

#include <util/delay.h>

#include "bmp085.h"

//path to i2c fleury lib

#include BMP085_I2CFLEURYPATH

/*

 * i2c write

 */

void bmp085_writemem(uint8_t reg, uint8_t value) {

        i2c_start_wait(BMP085_ADDR | I2C_WRITE);

        i2c_write(reg);

        i2c_write(value);

        i2c_stop();

}

/*

 * i2c read

 */

void bmp085_readmem(uint8_t reg, uint8_t buff[], uint8_t bytes) {

        uint8_t i =0;

        i2c_start_wait(BMP085_ADDR | I2C_WRITE);

        i2c_write(reg);

        i2c_rep_start(BMP085_ADDR | I2C_READ);

        for(i=0; i<bytes; i++) {

                if(i==bytes-1)

                        buff[i] = i2c_readNak();

                else

                        buff[i] = i2c_readAck();

        }

        i2c_stop();

}

#if BMP085_FILTERPRESSURE == 1

#define BMP085_AVARAGECOEF 21

static long k[BMP085_AVARAGECOEF];

long bmp085_avaragefilter(long input) {

        uint8_t i=0;

        long sum=0;

        for (i=0; i<BMP085_AVARAGECOEF; i++) {

                k[i] = k[i+1];

        }

        k[BMP085_AVARAGECOEF-1] = input;

        for (i=0; i<BMP085_AVARAGECOEF; i++) {

                sum += k[i];

        }

        return (sum /BMP085_AVARAGECOEF) ;

}

#endif

/*

 * read calibration registers

 */

void bmp085_getcalibration() {

        uint8_t buff[2];

        memset(buff, 0, sizeof(buff));

        bmp085_readmem(BMP085_REGAC1, buff, 2);

        bmp085_regac1 = ((int)buff[0] <<8 | ((int)buff[1]));

        bmp085_readmem(BMP085_REGAC2, buff, 2);

        bmp085_regac2 = ((int)buff[0] <<8 | ((int)buff[1]));

        bmp085_readmem(BMP085_REGAC3, buff, 2);

        bmp085_regac3 = ((int)buff[0] <<8 | ((int)buff[1]));

        bmp085_readmem(BMP085_REGAC4, buff, 2);

        bmp085_regac4 = ((unsigned int)buff[0] <<8 | ((unsigned int)buff[1]));

        bmp085_readmem(BMP085_REGAC5, buff, 2);

        bmp085_regac5 = ((unsigned int)buff[0] <<8 | ((unsigned int)buff[1]));

        bmp085_readmem(BMP085_REGAC6, buff, 2);

        bmp085_regac6 = ((unsigned int)buff[0] <<8 | ((unsigned int)buff[1]));

        bmp085_readmem(BMP085_REGB1, buff, 2);

        bmp085_regb1 = ((int)buff[0] <<8 | ((int)buff[1]));

        bmp085_readmem(BMP085_REGB2, buff, 2);

        bmp085_regb2 = ((int)buff[0] <<8 | ((int)buff[1]));

        bmp085_readmem(BMP085_REGMB, buff, 2);

        bmp085_regmb = ((int)buff[0] <<8 | ((int)buff[1]));

        bmp085_readmem(BMP085_REGMC, buff, 2);

        bmp085_regmc = ((int)buff[0] <<8 | ((int)buff[1]));

        bmp085_readmem(BMP085_REGMD, buff, 2);

        bmp085_regmd = ((int)buff[0] <<8 | ((int)buff[1]));

}

/*

 * get raw temperature as read by registers, and do some calculation to convert it

 */

void bmp085_getrawtemperature() {

        uint8_t buff[2];

        memset(buff, 0, sizeof(buff));

        long ut,x1,x2;

        //read raw temperature

        bmp085_writemem(BMP085_REGCONTROL, BMP085_REGREADTEMPERATURE);

        _delay_ms(5); // min. 4.5ms read Temp delay

        bmp085_readmem(BMP085_REGCONTROLOUTPUT, buff, 2);

        ut = ((long)buff[0] << 8 | ((long)buff[1])); //uncompensated temperature value

        //calculate raw temperature

        x1 = ((long)ut - bmp085_regac6) * bmp085_regac5 >> 15;

        x2 = ((long)bmp085_regmc << 11) / (x1 + bmp085_regmd);

        bmp085_rawtemperature = x1 + x2;

}

/*

 * get raw pressure as read by registers, and do some calculation to convert it

 */

void bmp085_getrawpressure() {

        uint8_t buff[3];

        memset(buff, 0, sizeof(buff));

        long up,x1,x2,x3,b3,b6,p;

        unsigned long b4,b7;

        #if BMP085_AUTOUPDATETEMP == 1

        bmp085_getrawtemperature();

        #endif

        //read raw pressure

        bmp085_writemem(BMP085_REGCONTROL, BMP085_REGREADPRESSURE+(BMP085_MODE << 6));

        _delay_ms(2 + (3<<BMP085_MODE));

        bmp085_readmem(BMP085_REGCONTROLOUTPUT, buff, 3);

        up = ((((long)buff[0] <<16) | ((long)buff[1] <<8) | ((long)buff[2])) >> (8-BMP085_MODE)); // uncompensated pressure value

        //calculate raw pressure

        b6 = bmp085_rawtemperature - 4000;

        x1 = (bmp085_regb2* (b6 * b6) >> 12) >> 11;

        x2 = (bmp085_regac2 * b6) >> 11;

        x3 = x1 + x2;

        b3 = (((((long)bmp085_regac1) * 4 + x3) << BMP085_MODE) + 2) >> 2;

        x1 = (bmp085_regac3 * b6) >> 13;

        x2 = (bmp085_regb1 * ((b6 * b6) >> 12)) >> 16;

        x3 = ((x1 + x2) + 2) >> 2;

        b4 = (bmp085_regac4 * (uint32_t)(x3 + 32768)) >> 15;

        b7 = ((uint32_t)up - b3) * (50000 >> BMP085_MODE);

        p = b7 < 0x80000000 ? (b7 << 1) / b4 : (b7 / b4) << 1;

        x1 = (p >> 8) * (p >> 8);

        x1 = (x1 * 3038) >> 16;

        x2 = (-7357 * p) >> 16;

        bmp085_rawpressure = p + ((x1 + x2 + 3791) >> 4);

        #if BMP085_FILTERPRESSURE == 1

        bmp085_rawpressure = bmp085_avaragefilter(bmp085_rawpressure);

        #endif

}

/*

 * get celsius temperature

 */

double bmp085_gettemperature() {

        bmp085_getrawtemperature();

        double temperature = ((bmp085_rawtemperature + 8)>>4);

        temperature = temperature /10;

        return temperature;

}

/*

 * get pressure

 */

int32_t bmp085_getpressure() {

        bmp085_getrawpressure();

        return bmp085_rawpressure + BMP085_UNITPAOFFSET;

}

/*

 * get altitude

 */

double bmp085_getaltitude() {

        bmp085_getrawpressure();

        return ((1 - pow(bmp085_rawpressure/(double)101325, 0.1903 )) / 0.0000225577) + BMP085_UNITMOFFSET;

}

/*

 * init bmp085

 */

void bmp085_init() {

        #if BMP085_I2CINIT == 1

        //init i2c

        i2c_init();

        _delay_us(10);

        #endif

        bmp085_getcalibration(); //get calibration data

        bmp085_getrawtemperature(); //update raw temperature, at least the first time

        #if BMP085_FILTERPRESSURE == 1

        //initialize the avarage filter

        uint8_t i=0;

        for (i=0; i<BMP085_AVARAGECOEF; i++) {

                bmp085_getrawpressure();

        }

        #endif

}

#endif