/* ----------------------------------------------------------------------------
 *         SAM Software Package License
 * ----------------------------------------------------------------------------
 * Copyright (c) 2015, Atmel Corporation
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the disclaimer below.
 *
 * Atmel's name may not be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
 * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * ----------------------------------------------------------------------------
 */

/**
  * \file
  *
  * Implementation BMP280 driver.
  *
  */

/*----------------------------------------------------------------------------
 *        Headers
 *----------------------------------------------------------------------------*/

#include "board.h"
#include "chip.h"
#include "math.h"
#include "misc/bmp280.h"
#include "peripherals/pio.h"
#include "peripherals/twid.h"
#include "peripherals/twi.h"
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>

/*------------------------------------------------------------------------------
 *         Local definitions
 *----------------------------------------------------------------------------*/

#define EPSILON (1e-10)

/*------------------------------------------------------------------------------
 *         Local functions
 *----------------------------------------------------------------------------*/

static uint8_t _bmp280_read(struct _bmp280* bmp280, uint8_t* buffer, uint32_t len)
{
	struct _buffer in = {
		.data = buffer,
		.size = len
	};
	return (uint8_t)twid_transfert(bmp280->twid, &in, 0, twid_finish_transfert_callback, 0);
}

static uint8_t _bmp280_write(struct _bmp280* bmp280, const uint8_t* buffer, uint32_t len)
{
	struct _buffer out = {
		.data = (uint8_t*)buffer,
		.size = len
	};
	return (uint8_t)twid_transfert(bmp280->twid, 0, &out, twid_finish_transfert_callback, 0);
}

/*------------------------------------------------------------------------------
 *         Global functions
 *----------------------------------------------------------------------------*/

/* Write the data to the given register
 *
 * Param addr -> Address of the register
 *       data -> The data from the register
 *       len -> no of bytes to read
 *
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_write_register(struct _bmp280* bmp280, uint8_t addr, uint8_t* pdata, uint8_t len)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return E_BMP280_NULL_PTR;
	else {
		bmp280->twid->iaddr = addr;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_write(bmp280, pdata, len);
	}
	return com_rslt;
}

/* Reads the data from the given register
 *
 * Param addr -> Address of the register
 *	 data -> The data from the register
 *	 len -> no of bytes to read
 *
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_read_register(struct _bmp280* bmp280, uint8_t addr, uint8_t* pdata, uint8_t len)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return E_BMP280_NULL_PTR;
	else {
		bmp280->twid->iaddr = addr;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, pdata, len);
	}
	return com_rslt;
}

/*
 * Read uncompensated temperature in the registers
 * 0xFA, 0xFB and 0xFC
 * 0xFA -> MSB -> bit from 0 to 7
 * 0xFB -> LSB -> bit from 0 to 7
 * 0xFC -> LSB -> bit from 4 to 7
 *
 * Param uncT : The uncompensated temperature.
 *
 * Return results of bus communication function
 *       0 -> Success
 *	-1 -> Error
 */
uint8_t bmp280_read_uncompensed_temperature (struct _bmp280* bmp280, int32_t* uncT)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	/* Array holding the MSB and LSb value
	   dt[0] - Temperature MSB
	   dt[1] - Temperature LSB
	   dt[2] - Temperature LSB
	*/
	uint8_t dt[3] = {0};

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return E_BMP280_NULL_PTR;
	else {
		/* read temperature data */
		bmp280->twid->iaddr = BMP280_TEMPERATURE_MSB_REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, &dt[0], 3);
		*uncT = (int32_t)((((uint32_t) (dt[0])) << 12) |
				  (((uint32_t)(dt[1])) << 4) | ((uint32_t)dt[2] >> 4));
	}
	return com_rslt;
}

/* Reads actual temperature from uncompensated temperature
 * Returns the value in 0.01 degree Centigrade
 * Output value of "5123" equals 51.23 DegC.
 *
 * param uncT : value of uncompensated temperature
 *
 * return Actual temperature output as s32
 */
int32_t bmp280_compensate_temperatureC (struct _bmp280* bmp280, int32_t uncT)
{
	int32_t x1 = 0;
	int32_t x2 = 0;
	int32_t temperature = 0;

	/* calculate true temperature*/
	x1  = ((((uncT >> 3) - ((int32_t)bmp280->calpar.dig_T1
				<< 1))) * ((int32_t)bmp280->calpar.dig_T2)) >> 11;
	x2  = (((((uncT >> 4) - ((int32_t)bmp280->calpar.dig_T1)) *
		 ((uncT >> 4) - ((int32_t)bmp280->calpar.dig_T1)))
		>> 12) * ((int32_t)bmp280->calpar.dig_T3)) >> 14;
	bmp280->calpar.t_fine = x1 + x2;
	temperature  = (bmp280->calpar.t_fine * BMP280_DEC_TRUE_TEMP_5 +
			BMP280_DEC_TRUE_TEMP_128) >> 8;
	return temperature;
}

/* Read uncompensated pressure.
 * in the registers 0xF7, 0xF8 and 0xF9
 * 0xF7 -> MSB -> bit from 0 to 7
 * 0xF8 -> LSB -> bit from 0 to 7
 * 0xF9 -> LSB -> bit from 4 to 7
 *
 * param uncP : The value of uncompensated pressure
 *
 * return results of bus communication function
 *       0 -> Success
 *	-1 -> Error
 */
uint8_t bmp280_read_uncompensed_pressure (struct _bmp280* bmp280, int32_t* uncP)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	/* Array holding the MSB and LSb value
	   dt[0] - Pressure MSB
	   dt[1] - Pressure LSB
	   dt[2] - Pressure LSB
	*/
	uint8_t dt[3] = {0};

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		bmp280->twid->iaddr = BMP280_PRESSURE_MSB_REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, &dt[0], 3);
		*uncP = (int32_t)((((uint32_t)(dt[0])) << 12) |
				  (((uint32_t)(dt[1])) << 4) | ((uint32_t)dt[2] >> 4));
	}
	return com_rslt;
}

/*
 * Reads actual pressure from uncompensated pressure and returns the value in
 * Pascal(Pa)
 *
 * Note: Output value of "96386" equals 96386 Pa = 963.86 hPa = 963.86 millibar
 *
 * Param  uncP: value of uncompensated pressure
 *
 * Return Returns the Actual pressure out put as s32
 */
uint32_t  bmp280_compensate_pressureP (struct _bmp280* bmp280, int32_t uncP)
{
	int32_t x1 = 0;
	int32_t x2 = 0;
	uint32_t pressure = 0;

	/* calculate true pressure*/
	x1 = (((int32_t)bmp280->calpar.t_fine) >> 1) - (int32_t)BMP280_DEC_TRUE_PRES_64000;
	x2 = (((x1 >> 2) * (x1 >> 2)) >> 11) * ((int32_t)bmp280->calpar.dig_P6);
	x2 = x2 + ((x1 * ((int32_t)bmp280->calpar.dig_P5)) << 1);
	x2 = (x2 >> 2) + (((int32_t)bmp280->calpar.dig_P4) << 16);
	x1 = (((bmp280->calpar.dig_P3 * (((x1 >> 2) * (x1 >> 2)) >> 13)) >> 3) +
	      ((((int32_t)bmp280->calpar.dig_P2) * x1) >> 1)) >> 18;
	x1 = ((((BMP280_DEC_TRUE_PRES_32768 + x1)) * ((int32_t)bmp280->calpar.dig_P1)) >> 15);
	pressure = (((uint32_t)(((int32_t)BMP280_DEC_TRUE_PRES_1048576) - uncP) -
		     (x2 >> 12))) * BMP280_DEC_TRUE_PRES_3125;

	if (pressure < BMP280_HEX_TRUE_PRES_8M)
		/* Avoid exception caused by division by zero */
		if (x1 != 0)
			pressure = (pressure << 1) / ((uint32_t)x1);
		else
			return 0;
	else
		/* Avoid exception caused by division by zero */
		if (x1 != 0)
			pressure = (pressure / (uint32_t)x1) * BMP280_DEC_TRUE_PRES_2;
		else
			return 0;

	x1 = (((int32_t)bmp280->calpar.dig_P9)* ((int32_t)(((pressure>>3)* (pressure>>3))>>13)))>>12 ;
	x2 = (((int32_t)(pressure >> 2))*((int32_t)bmp280->calpar.dig_P8))>>13;
	pressure = (uint32_t)((int32_t)pressure + ((x1 + x2 + bmp280->calpar.dig_P7)>>4));

	return pressure;
}


/*
 * Reads uncompensated pressure and temperature
 *
 * Param uncP: The value of uncompensated pressure.
 *       uncT: The value of uncompensated temperature.
 *
 * Return results of bus communication function
 *	0 -> Success
 *	-1 -> Error
 */
uint8_t bmp280_read_uncompensed_pressure_temperature (struct _bmp280* bmp280, int32_t* uncP, int32_t* uncT)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;

	/* Array holding the temperature and pressure data
	   dt[0] - Pressure MSB
	   dt[1] - Pressure LSB
	   dt[2] - Pressure LSB
	   dt[3] - Temperature MSB
	   dt[4] - Temperature LSB
	   dt[5] - Temperature LSB
	*/
	uint8_t dt[6] = {0};

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		bmp280->twid->iaddr = BMP280_PRESSURE_MSB_REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, &dt[0], 6);
		/*Pressure*/
		*uncP = (int32_t)((((uint32_t)(dt[0]))<<12) | (((uint32_t)(dt[1]))<<4) | ((uint32_t)dt[2]>>4));
		/* Temperature */
		*uncT = (int32_t)((((uint32_t)(dt[3]))<<12) | (((uint32_t)(dt[4]))<<4) | ((uint32_t)dt[5]>>4));
	}
	return com_rslt;
}

/*
 * Reads the true pressure and temperature
 *
 * Param pressure : The value of compensated pressure.
 *       temperature : The value of compensated temperature.
 *
 * Return results of bus communication function
 *	0 -> Success
 *	-1 -> Error
 */

uint8_t bmp280_read_pressure_temperature (struct _bmp280* bmp280, uint32_t* pressure, int32_t* temperature)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	int32_t uncP = 0;
	int32_t uncT = 0;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		/* read uncompensated pressure and temperature*/
		com_rslt = bmp280_read_uncompensed_pressure_temperature(bmp280, &uncP, &uncT);
		/* read true pressure and temperature*/
		*temperature = bmp280_compensate_temperatureC(bmp280, uncT);
		*pressure = bmp280_compensate_pressureP(bmp280, uncP);
	}
	return com_rslt;
}

/*
 * Calibration parameters used for calculation in the registers
 *
 *  parameter | Register address |   bit
 *------------|------------------|----------------
 *	dig_T1    |  0x88 and 0x89   | from 0 : 7 to 8: 15
 *	dig_T2    |  0x8A and 0x8B   | from 0 : 7 to 8: 15
 *	dig_T3    |  0x8C and 0x8D   | from 0 : 7 to 8: 15
 *	dig_P1    |  0x8E and 0x8F   | from 0 : 7 to 8: 15
 *	dig_P2    |  0x90 and 0x91   | from 0 : 7 to 8: 15
 *	dig_P3    |  0x92 and 0x93   | from 0 : 7 to 8: 15
 *	dig_P4    |  0x94 and 0x95   | from 0 : 7 to 8: 15
 *	dig_P5    |  0x96 and 0x97   | from 0 : 7 to 8: 15
 *	dig_P6    |  0x98 and 0x99   | from 0 : 7 to 8: 15
 *	dig_P7    |  0x9A and 0x9B   | from 0 : 7 to 8: 15
 *	dig_P8    |  0x9C and 0x9D   | from 0 : 7 to 8: 15
 *	dig_P9    |  0x9E and 0x9F   | from 0 : 7 to 8: 15
 *
 * Return results of bus communication function
 *	0 -> Success
 *	-1 -> Error
 */
uint8_t bmp280_get_calpar (struct _bmp280* bmp280)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	uint8_t dt[26] = {0};

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		bmp280->twid->iaddr = BMP280_DIG_T1_LSB_REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, &dt[0], 24);
		/* read calibration values*/
		bmp280->calpar.dig_T1 = (uint16_t)((((uint16_t)((uint8_t)dt[1])) << 8) | dt[0]);
		bmp280->calpar.dig_T2 = (int16_t)((((int16_t)((int8_t)dt[3])) << 8) | dt[2]);
		bmp280->calpar.dig_T3 = (int16_t)((((int16_t)((int8_t)dt[5])) << 8) | dt[4]);
		bmp280->calpar.dig_P1 = (uint16_t)((((uint16_t)((uint8_t)dt[7])) << 8) | dt[6]);
		bmp280->calpar.dig_P2 = (int16_t)((((int16_t)((int8_t)dt[9])) << 8) | dt[8]);
		bmp280->calpar.dig_P3 = (int16_t)((((int16_t)((int8_t)dt[11])) << 8) | dt[10]);
		bmp280->calpar.dig_P4 = (int16_t)((((int16_t)((int8_t)dt[13])) << 8) | dt[12]);
		bmp280->calpar.dig_P5 = (int16_t)((((int16_t)((int8_t)dt[15])) << 8) | dt[14]);
		bmp280->calpar.dig_P6 = (int16_t)((((int16_t)((int8_t)dt[17])) << 8) | dt[16]);
		bmp280->calpar.dig_P7 = (int16_t)((((int16_t)((int8_t)dt[19])) << 8) | dt[18]);
		bmp280->calpar.dig_P8 = (int16_t)((((int16_t)((int8_t)dt[21])) << 8) | dt[20]);
		bmp280->calpar.dig_P9 = (int16_t)((((int16_t)((int8_t)dt[23])) << 8) | dt[22]);
	}
	return com_rslt;
}

/* Get the temperature oversampling setting in the register 0xF4
 * bits from 5 to 7
 *
 *        value             | Temperature oversampling
 *  ------------------------|------------------------------
 *       0x00               |  Skipped
 *       0x01               |  BMP280_OVERSAMP_1X
 *       0x02               |  BMP280_OVERSAMP_2X
 *       0x03               |  BMP280_OVERSAMP_4X
 *       0x04               |  BMP280_OVERSAMP_8X
 *       0x05,0x06 and 0x07 |  BMP280_OVERSAMP_16X
 *
 * Param: value :The value of temperature over sampling
 *
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_get_overs_temp (struct _bmp280* bmp280, uint8_t* value)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	uint8_t data = 0;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		/* read temperature over sampling*/
		bmp280->twid->iaddr = BMP280_CTRL_MEAS_REG_OVRS_TEMP__REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, &data, 1);
		*value = BMP280_GET_BITSLICE(data, BMP280_CTRL_MEAS_REG_OVRS_TEMP);
		/* assign temperature oversampling*/
		bmp280->overs_temp = *value;
	}
	return com_rslt;
}

/* Set the temperature oversampling setting in the register 0xF4
 * bits from 5 to 7
 *
 *        value             | Temperature oversampling
 *  ------------------------|------------------------------
 *       0x00               |  Skipped
 *       0x01               |  BMP280_OVERSAMP_1X
 *       0x02               |  BMP280_OVERSAMP_2X
 *       0x03               |  BMP280_OVERSAMP_4X
 *       0x04               |  BMP280_OVERSAMP_8X
 *       0x05,0x06 and 0x07 |  BMP280_OVERSAMP_16X
 *
 * Param: value :The value of temperature over sampling
 *
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_set_overs_temp (struct _bmp280* bmp280, uint8_t value)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	uint8_t data = 0;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		bmp280->twid->iaddr = BMP280_CTRL_MEAS_REG_OVRS_TEMP__REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, &data, 1);
		if (com_rslt == SUCCESS) {
			/* write over sampling*/
			data = BMP280_SET_BITSLICE(data, BMP280_CTRL_MEAS_REG_OVRS_TEMP, value);
			bmp280->twid->iaddr = BMP280_CTRL_MEAS_REG_OVRS_TEMP__REG;
			bmp280->twid->isize = 1;
			com_rslt = _bmp280_write(bmp280, &data, 1);
			bmp280->overs_temp = value;
		}
	}
	return com_rslt;
}

/* Get the pressure oversampling setting in the register 0xF4
 * bits from 2 to 4
 *
 *        value             | Pressure oversampling
 *  ------------------------|------------------------------
 *       0x00               |  Skipped
 *       0x01               |  BMP280_OVERSAMP_1X
 *       0x02               |  BMP280_OVERSAMP_2X
 *       0x03               |  BMP280_OVERSAMP_4X
 *       0x04               |  BMP280_OVERSAMP_8X
 *       0x05,0x06 and 0x07 |  BMP280_OVERSAMP_16X
 *
 * Param:  value : The value of pressure over sampling
 *
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_get_overs_pres (struct _bmp280* bmp280, uint8_t* value)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	uint8_t data = 0;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		/* read pressure over sampling */
		bmp280->twid->iaddr = BMP280_CTRL_MEAS_REG_OVRS_PRES__REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, &data, 1);
		*value = BMP280_GET_BITSLICE(data, BMP280_CTRL_MEAS_REG_OVRS_PRES);
		bmp280->overs_pres = *value;
	}
	return com_rslt;
}

/* Set the pressure oversampling setting in the register 0xF4
 * bits from 2 to 4
 *
 *        value             | Pressure oversampling
 *  ------------------------|------------------------------
 *       0x00               |  Skipped
 *       0x01               |  BMP280_OVERSAMP_1X
 *       0x02               |  BMP280_OVERSAMP_2X
 *       0x03               |  BMP280_OVERSAMP_4X
 *       0x04               |  BMP280_OVERSAMP_8X
 *       0x05,0x06 and 0x07 |  BMP280_OVERSAMP_16X
 *
 * Param:  value : The value of pressure over sampling
 *
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_set_overs_pres (struct _bmp280* bmp280, uint8_t value)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	uint8_t data = 0;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		bmp280->twid->iaddr = BMP280_CTRL_MEAS_REG_OVRS_PRES__REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, &data, 1);
		if (com_rslt == SUCCESS) {
			/* write pressure over sampling */
			data = BMP280_SET_BITSLICE(data, BMP280_CTRL_MEAS_REG_OVRS_PRES, value);
			bmp280->twid->iaddr = BMP280_CTRL_MEAS_REG_OVRS_PRES__REG;
			bmp280->twid->isize = 1;
			com_rslt = _bmp280_write(bmp280, &data, 1);
			bmp280->overs_pres = value;
		}
	}
	return com_rslt;
}

/* Get the operational Mode from the sensor in the register 0xF4 bit 0 and 1
 *
 * Param: power_mode : The value of power mode value
 *  value            |   Power mode
 * ------------------|------------------
 *	0x00             | BMP280_SLEEP_MODE
 *	0x01 and 0x02    | BMP280_FORCED_MODE
 *	0x03             | BMP280_NORMAL_MODE
 *
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_get_power_mode(struct _bmp280* bmp280, uint8_t* power_mode)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	uint8_t mode = 0;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		/* read the power mode*/
		bmp280->twid->iaddr = BMP280_CTRL_MEAS_REG_POWER_MODE__REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, &mode, 1);
		*power_mode = BMP280_GET_BITSLICE(mode, BMP280_CTRL_MEAS_REG_POWER_MODE);
	}
	return com_rslt;
}

/* Set the operational Mode from the sensor in the register 0xF4 bit 0 and 1
 *
 * Param: power_mode : The value of power mode value
 *  value            |   Power mode
 * ------------------|------------------
 *	0x00             | BMP280_SLEEP_MODE
 *	0x01 and 0x02    | BMP280_FORCED_MODE
 *	0x03             | BMP280_NORMAL_MODE
 *
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_set_power_mode (struct _bmp280* bmp280, uint8_t power_mode)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	uint8_t mode = 0;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else
	{
		if (power_mode < 4) {
			/* write the power mode*/
			mode = (bmp280->overs_temp << 5) + (bmp280->overs_pres << 2) + power_mode;
			bmp280->twid->iaddr = BMP280_CTRL_MEAS_REG_POWER_MODE__REG;
			bmp280->twid->isize = 1;
			com_rslt = _bmp280_write(bmp280, &mode, 1);
		}
		else {
			com_rslt = E_BMP280_OUT_OF_RANGE;
		}
	}
	return com_rslt;
}

/* Reset the sensor
 * The value 0xB6 is written to the 0xE0 register the device is reset using the
 * complete power-on-reset procedure.
 * Softreset can be easily set using bmp280_set_softreset().
 *
 * Note Usage Hint : bmp280_set_softreset()
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_set_soft_rst (struct _bmp280* bmp280)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	uint8_t data = BMP280_SOFT_RESET_CODE;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		/* write soft reset */
		bmp280->twid->iaddr = BMP280_RST_REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_write(bmp280, &data, 1);
	}
	return com_rslt;
}

/* Get the sensor SPI mode(communication type) in the register 0xF5 bit 0
 *
 * Param: enable_disable : The spi3 enable or disable state
 *    value    | Description
 *  -----------|---------------
 *     0       | Disable
 *     1       | Enable
 *
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_get_spi3 (struct _bmp280* bmp280, uint8_t* enable_disable)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	uint8_t data = 0;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		bmp280->twid->iaddr = BMP280_CONFIG_REG_SPI3_ENABLE__REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, &data, 1);
		*enable_disable = BMP280_GET_BITSLICE(data, BMP280_CONFIG_REG_SPI3_ENABLE);
	}
	return com_rslt;
}

/* Set the sensor SPI mode(communication type) in the register 0xF5 bit 0
 *
 * Param: enable_disable : The spi3 enable or disable state
 *    value    | Description
 *  -----------|---------------
 *     0       | Disable
 *     1       | Enable
 *
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_set_spi3 (struct _bmp280* bmp280, uint8_t enable_disable)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	uint8_t data = 0;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		bmp280->twid->iaddr = BMP280_CONFIG_REG_SPI3_ENABLE__REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, &data, 1);
		if (com_rslt == SUCCESS) {
			data = BMP280_SET_BITSLICE(data, BMP280_CONFIG_REG_SPI3_ENABLE, enable_disable);
			bmp280->twid->iaddr = BMP280_CONFIG_REG_SPI3_ENABLE__REG;
			bmp280->twid->isize = 1;
			com_rslt = _bmp280_write(bmp280, &data, 1);
		}
	}
	return com_rslt;
}

/* Reads filter setting in the register 0xF5 bit 3 and 4
 *
 * Param value : The value of filter coefficient
 *	value	    |	Filter coefficient
 * -------------|-------------------------
 *	0x00        | BMP280_FILTER_COEFF_OFF
 *	0x01        | BMP280_FILTER_COEFF_2
 *	0x02        | BMP280_FILTER_COEFF_4
 *	0x03        | BMP280_FILTER_COEFF_8
 *	0x04        | BMP280_FILTER_COEFF_16
 *
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_get_filter (struct _bmp280* bmp280, uint8_t *value)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	uint8_t data = 0;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		/* read filter*/
		bmp280->twid->iaddr = BMP280_CONFIG_REG_FILTER__REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, &data, 1);
		*value = BMP280_GET_BITSLICE(data, BMP280_CONFIG_REG_FILTER);
	}
	return com_rslt;
}

/* Write filter setting in the register 0xF5 bit 3 and 4
 *
 * Param value : The value of filter coefficient
 *	value	    |	Filter coefficient
 * -------------|-------------------------
 *	0x00        | BMP280_FILTER_COEFF_OFF
 *	0x01        | BMP280_FILTER_COEFF_2
 *	0x02        | BMP280_FILTER_COEFF_4
 *	0x03        | BMP280_FILTER_COEFF_8
 *	0x04        | BMP280_FILTER_COEFF_16
 *
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_set_filter (struct _bmp280* bmp280, uint8_t value)
{
	uint8_t com_rslt = SUCCESS;
	uint8_t data = 0;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		/* write filter*/
		bmp280->twid->iaddr = BMP280_CONFIG_REG_FILTER__REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, &data, 1);
		if (com_rslt == SUCCESS) {
			data = BMP280_SET_BITSLICE(data, BMP280_CONFIG_REG_FILTER, value);
			bmp280->twid->iaddr = BMP280_CONFIG_REG_FILTER__REG;
			bmp280->twid->isize = 1;
			com_rslt = _bmp280_write(bmp280, &data, 1);
		}
	}
	return com_rslt;
}

/* Read the standby duration time from the sensor in the register 0xF5 bit 5 to 7
 *
 * Param standby_durn : The standby duration time value.
 *  value     |  standby duration
 * -----------|--------------------
 *    0x00    | BMP280_STANDBYTIME_1_MS
 *    0x01    | BMP280_STANDBYTIME_63_MS
 *    0x02    | BMP280_STANDBYTIME_125_MS
 *    0x03    | BMP280_STANDBYTIME_250_MS
 *    0x04    | BMP280_STANDBYTIME_500_MS
 *    0x05    | BMP280_STANDBYTIME_1000_MS
 *    0x06    | BMP280_STANDBYTIME_2000_MS
 *    0x07    | BMP280_STANDBYTIME_4000_MS
 *
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_get_standby_durn(struct _bmp280* bmp280, uint8_t* standby_durn)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	uint8_t data = 0;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		/* read the standby duration*/
		bmp280->twid->iaddr = BMP280_CONFIG_REG_STANDBY_DURN__REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, &data, 1);
		*standby_durn = BMP280_GET_BITSLICE(data, BMP280_CONFIG_REG_STANDBY_DURN);
	}
	return com_rslt;
}

/* Read the standby duration time from the sensor in the register 0xF5 bit 5 to 7
 *
 * Note Normal mode comprises an automated perpetual cycling between an (active)
 *      Measurement period and an (inactive) standby period.
 * Note The standby time is determined by the contents of the register t_sb.
 *	Standby time can be set using BME280_STANDBYTIME_125_MS.
 * Note bme280_set_standby_durN(BME280_STANDBYTIME_125_MS)
 *
 * Param standby_durn : The standby duration time value.
 *  value     |  standby duration
 * -----------|--------------------
 *    0x00    | BMP280_STANDBYTIME_1_MS
 *    0x01    | BMP280_STANDBYTIME_63_MS
 *    0x02    | BMP280_STANDBYTIME_125_MS
 *    0x03    | BMP280_STANDBYTIME_250_MS
 *    0x04    | BMP280_STANDBYTIME_500_MS
 *    0x05    | BMP280_STANDBYTIME_1000_MS
 *    0x06    | BMP280_STANDBYTIME_2000_MS
 *    0x07    | BMP280_STANDBYTIME_4000_MS
 *
 *  @return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_set_standby_durn (struct _bmp280* bmp280, uint8_t standby_durn)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	uint8_t data = 0;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		/* write the standby duration*/
		bmp280->twid->iaddr = BMP280_CONFIG_REG_STANDBY_DURN__REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_read(bmp280, &data, 1);
		if (com_rslt == SUCCESS) {
			data = BMP280_SET_BITSLICE(data, BMP280_CONFIG_REG_STANDBY_DURN, standby_durn);
			bmp280->twid->iaddr = BMP280_CONFIG_REG_STANDBY_DURN__REG;
			bmp280->twid->isize = 1;
			com_rslt = _bmp280_write(bmp280, &data, 1);
		}
	}
	return com_rslt;
}

/* Write the working mode of the sensor
 *
 * Param work_mode : The value of work mode
 *   value      |  mode
 * -------------|-------------
 *    0         | BMP280_ULTRA_LOW_POWER_MODE
 *    1         | BMP280_LOW_POWER_MODE
 *    2         | BMP280_STANDARD_RESOLUTION_MODE
 *    3         | BMP280_HIGH_RESOLUTION_MODE
 *    4         | BMP280_ULTRA_HIGH_RESOLUTION_MODE
 *
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_set_work_mode (struct _bmp280* bmp280, uint8_t work_mode)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	uint8_t data = 0;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		if (work_mode <= 4) {
			bmp280->twid->iaddr = BMP280_CTRL_MEAS_REG;
			bmp280->twid->isize = 1;
			com_rslt = _bmp280_read(bmp280, &data, 1);
			if (com_rslt == SUCCESS)
			{
				switch (work_mode) {
					/* write work mode*/
				case BMP280_ULTRA_LOW_POWER_MODE:
					bmp280->overs_temp = BMP280_ULTRALOWPOWER_OVRS_TEMP;
					bmp280->overs_pres = BMP280_ULTRALOWPOWER_OVRS_PRES;
					break;
				case BMP280_LOW_POWER_MODE:
					bmp280->overs_temp = BMP280_LOWPOWER_OVRS_TEMP;
					bmp280->overs_pres = BMP280_LOWPOWER_OVRS_PRES;
					break;
				case BMP280_STANDARD_RESOLUTION_MODE:
					bmp280->overs_temp = BMP280_STANDARDRESOLUTION_OVRS_TEMP;
					bmp280->overs_pres = BMP280_STANDARDRESOLUTION_OVRS_PRES;
					break;
				case BMP280_HIGH_RESOLUTION_MODE:
					bmp280->overs_temp = BMP280_HIGHRESOLUTION_OVRS_TEMP;
					bmp280->overs_pres = BMP280_HIGHRESOLUTION_OVRS_PRES;
					break;
				case BMP280_ULTRA_HIGH_RESOLUTION_MODE:
					bmp280->overs_temp = BMP280_ULTRAHIGHRESOLUTION_OVRS_TEMP;
					bmp280->overs_pres = BMP280_ULTRAHIGHRESOLUTION_OVRS_PRES;
					break;
				}
				data = BMP280_SET_BITSLICE(data, BMP280_CTRL_MEAS_REG_OVRS_TEMP, bmp280->overs_temp);
				data = BMP280_SET_BITSLICE(data, BMP280_CTRL_MEAS_REG_OVRS_PRES, bmp280->overs_pres);
				bmp280->twid->iaddr = BMP280_CTRL_MEAS_REG;
				bmp280->twid->isize = 1;
				com_rslt = _bmp280_write(bmp280, &data, 1);
			}
		}
		else {
			com_rslt = E_BMP280_OUT_OF_RANGE;
		}
	}
	return com_rslt;
}

/* Read both uncompensated pressure and temperature in forced mode
 *
 * Param  uncP: The value of uncompensated pressure.
 *        uncT: The value of uncompensated temperature
 *
 * Return results of bus communication function
 *	@retval 0 -> Success
 *	@retval -1 -> Error
 */
uint8_t bmp280_get_forced_uncP_temperature(struct _bmp280* bmp280, int32_t* uncP, int32_t* uncT)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = ERROR;
	uint8_t data = 0;
	uint8_t waittime = 0;

	/* check the bmp280 struct pointer as NULL*/
	if (bmp280 == BMP280_NULL)
		return  E_BMP280_NULL_PTR;
	else {
		/* read pressure and temperature*/
		data = (bmp280->overs_temp << 5) + (bmp280->overs_pres << 2) + BMP280_FORCED_MODE;
		bmp280->twid->iaddr = BMP280_CTRL_MEAS_REG;
		bmp280->twid->isize = 1;
		com_rslt = _bmp280_write(bmp280, &data, 1);
		bmp280_compute_wait_time(bmp280, &waittime);
		bmp280->delay_msec(waittime);
		com_rslt += bmp280_read_uncompensed_pressure_temperature(bmp280, uncP, uncT);
	}
	return com_rslt;
}


#ifdef BMP280_ENABLE_FLOAT
/* Read actual temperature from uncompensated temperature
 *
 * Note Returns the value in Degree centigrade
 *      Output value of "51.23" equals 51.23 DegC.
 *
 * Param uncT : value of uncompensated temperature
 *
 * Return Actual temperature in floating point
 */
double bmp280_compensate_T_double(struct _bmp280* bmp280, int32_t uncT)
{
	double x1 = 0;
	double x2 = 0;
	double temperature = 0;

	x1 = (((double)uncT) / BMP280_FLOAT_TRUE_TEMP_16384 -
	      ((double)bmp280->calpar.dig_T1) / BMP280_FLOAT_TRUE_TEMP_1024) *
		((double)bmp280->calpar.dig_T2);
	x2 = ((((double)uncT) / BMP280_FLOAT_TRUE_TEMP_131072 -
	       ((double)bmp280->calpar.dig_T1) / BMP280_FLOAT_TRUE_TEMP_8192) *
	      (((double)uncT) / BMP280_FLOAT_TRUE_TEMP_131072 -
	       ((double)bmp280->calpar.dig_T1) / BMP280_FLOAT_TRUE_TEMP_8192)) *
		((double)bmp280->calpar.dig_T3);
	bmp280->calpar.t_fine = (int32_t)(x1 + x2);
	temperature  = (x1 + x2) / BMP280_FLOAT_TRUE_TEMP_5120;
	return temperature;
}

/* Reads actual pressure from uncompensated pressure and returns pressure in
 * Pa as double.
 *
 * Note Output value of "96386.2" equals 96386.2 Pa = 963.862 hPa.
 *
 * Param uncP : value of uncompensated pressure
 *
 * Return Actual pressure in floating point
 */
double bmp280_compensate_P_double(struct _bmp280* bmp280, int32_t uncP)
{
	double x1 = 0;
	double x2 = 0;
	double pressure = 0;

	x1 = ((double)bmp280->calpar.t_fine / BMP280_FLOAT_TRUE_PRES_2) -
		BMP280_FLOAT_TRUE_PRES_64000;
	x2 = x1 * x1 * ((double)bmp280->calpar.dig_P6) /
		BMP280_FLOAT_TRUE_PRES_32768;
	x2 = x2 + x1 * ((double)bmp280->calpar.dig_P5)
		* BMP280_FLOAT_TRUE_PRES_2;
	x2 = (x2 / BMP280_FLOAT_TRUE_PRES_4) + ((double)bmp280->calpar.dig_P4)
		* BMP280_FLOAT_TRUE_PRES_65536;
	x1 = (((double)bmp280->calpar.dig_P3) * x1 * x1
	      / BMP280_FLOAT_TRUE_PRES_524288 + ((double)bmp280->calpar.dig_P2) * x1)
		/ BMP280_FLOAT_TRUE_PRES_524288;
	x1 = (BMP280_FLOAT_TRUE_PRES_1 + x1 / BMP280_FLOAT_TRUE_PRES_32768) *
		((double)bmp280->calpar.dig_P1);
	pressure = BMP280_FLOAT_TRUE_PRES_1048576 - (double)uncP;
	/* Avoid exception caused by division by zero */
	if (fabs(x1) >= EPSILON)
		pressure = (pressure - (x2 / BMP280_FLOAT_TRUE_PRES_4096)) *
			BMP280_FLOAT_TRUE_PRES_6250 / x1;
	else
		return BMP280_FLOAT_TRUE_PRES_0;
	x1 = ((double)bmp280->calpar.dig_P9) * pressure * pressure /
		BMP280_FLOAT_TRUE_PRES_2147483648;
	x2 = pressure * ((double)bmp280->calpar.dig_P8) / BMP280_FLOAT_TRUE_PRES_32768;
	pressure = pressure + (x1 + x2 + ((double)bmp280->calpar.dig_P7))
		/ BMP280_FLOAT_TRUE_PRES_1_6;

	return pressure;
}
#endif


#if defined(BMP280_ENABLE_INT64) && defined(BMP280_64BITSUPPORT_PRESENT)
/* Read actual pressure from uncompensated pressure
 *
 * Note returns the value in Pa as unsigned 32 bit integer in Q24.8 format
 * (24 integer bits and 8 fractional bits). Output value of "24674867"
 * represents 24674867 / 256 = 96386.2 Pa = 963.862 hPa
 *
 * Param uncP : value of uncompensated pressure
 *
 * Return actual pressure as 64bit output
 */
uint32_t bmp280_compensate_P_int64(struct _bmp280* bmp280, int32_t uncP)
{
	int64_t x1_s64r = 0;
	int64_t x2_s64r = 0;
	int64_t pressure = 0;

	x1_s64r = ((int64_t)bmp280->calpar.t_fine) -
		BMP280_TRUE_PRES_128000;
	x2_s64r = x1_s64r * x1_s64r * (int64_t)bmp280->calpar.dig_P6;
	x2_s64r = x2_s64r + ((x1_s64r * (int64_t)bmp280->calpar.dig_P5) << 17);
	x2_s64r = x2_s64r + (((int64_t)bmp280->calpar.dig_P4) << 35);
	x1_s64r = ((x1_s64r * x1_s64r * (int64_t)bmp280->calpar.dig_P3) >> 8) +
		((x1_s64r * (int64_t)bmp280->calpar.dig_P2) << 12);
	x1_s64r = (((((int64_t)BMP280_TRUE_PRES_1) << 47) + x1_s64r)) *
		((int64_t)bmp280->calpar.dig_P1) >> 33;
	pressure = BMP280_TRUE_PRES_1048576 - uncP;

	if (x1_s64r != 0)
#if defined __KERNEL__
	pressure = div64_s64((((pressure << 31) - x2_s64r)
						  * BMP280_TRUE_PRES_3125), x1_s64r);
#else
	pressure = (((pressure << 31) - x2_s64r)
				* BMP280_TRUE_PRES_3125) / x1_s64r;
#endif
	else
		return 0;

	x1_s64r = (((int64_t)bmp280->calpar.dig_P9) * (pressure >> 13) *
		   (pressure >> 13)) >> 25;
	x2_s64r = (((int64_t)bmp280->calpar.dig_P8) * pressure) >> 19;
	pressure = ((pressure + x1_s64r + x2_s64r)	>> 8) +
		(((int64_t)bmp280->calpar.dig_P7) << 4);
	return (uint32_t)pressure;
}
#endif

/* Computing waiting time for sensor data read
 *
 * Param delaytimer: The value of delay time
 *
 * Return 0
 */
uint8_t bmp280_compute_wait_time (struct _bmp280* bmp280, uint8_t* delaytimer)
{
	/* variable used to return communication result*/
	uint8_t com_rslt = SUCCESS;

	*delaytimer = (T_INIT_MAX + T_MEASURE_PER_OSRS_MAX *
		       (((1 << bmp280->overs_temp) >> 1) +
			((1 << bmp280->overs_pres) >> 1)) +
		       (bmp280->overs_pres ? T_SETUP_PRESSURE_MAX : 0) + 15) / 16;
	return com_rslt;
}

/*
 *	Read ID and Calibration parameters
 *  Return results of bus communication function
 *	0 -> Success
 *	-1 -> Error
 */
uint8_t bmp280_read_id_get_calib_param (struct _bmp280* bmp280)
{
	/* variable used to return communication result*/
	uint8_t com_rslt;
	uint8_t data = 0;

	/* read chip id */
	bmp280->twid->iaddr = BMP280_CHIP_ID_REG;
	bmp280->twid->isize = 1;
	com_rslt = _bmp280_read(bmp280, &data, 1);
	bmp280->chip_id = data;
	if ( data != BMP280_CHIP_ID ) {
		printf(" -E- Error Chip ID : 0x%x \n\r", data);
		com_rslt = ERROR;
	}
	else {
		printf(" -I- Chip ID: 0x%x \n\r", data);
		/* readout bmp280 calibration parameter structure */
		com_rslt += bmp280_get_calpar(bmp280);
	}
	return com_rslt;
}

// End of file