/*
 * test.c
 *
 * Created: 06/08/2018 10:27:43 AM
 * Author : jitendra
 */ 

#include <avr/io.h>
#include<avr/eeprom.h>
#define F_CPU 8000000UL
#define DEVICES	1
#include<util/delay.h>
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include<inttypes.h>
#include<util/twi.h>
#include<avr/pgmspace.h>
#include<avr/wdt.h>
#include<avr/power.h>
#include<avr/interrupt.h>
#include "main.h"
#include "SPI.h"
#include "UART.h"
#include "bmp280_fun.h"
struct bmp280_dev bmp[DEVICES];
struct bmp280_config conf;
//char data[400] ;
static int uart_putchar(char c, FILE *stream);
static FILE mystdout = FDEV_SETUP_STREAM(uart_putchar, NULL, _FDEV_SETUP_WRITE);

/* for (uint8_t i=0;i<DEVICES,i++)
{
	struct bmp280_dev bmp[i];
} */
static int uart_putchar(char c, FILE *stream)
{
	if (c == '\n') uart_putchar('\r', stream);
	
	loop_until_bit_is_set(UCSR0A, UDRE0);
	UDR0 = c;
	
	return 0;
}

void init_bmp280(struct bmp280_dev *dev)
{
	//struct bmp280_dev bmp;
	//char tbuf [50];
	int8_t rslt;
	//bmp.dev_id  =  0;
	//bmp.intf = BMP280_SPI_INTF;
	//bmp.read = user_spi_read;
	//bmp.write = user_spi_write;
	//bmp.delay_ms = user_delay_ms;
	//for (int i=0;i<100;i++);
	for (uint8_t i = 0; i < DEVICES; i++)
	{
		//bmp.dev_id  =  i;
		//rslt = bmp280_init(&bmp); //reads the chip-id and calibration data from the sensor
		dev[i].intf = BMP280_SPI_INTF;
		dev[i].read = user_spi_read;
		dev[i].write = user_spi_write;
		dev[i].delay_ms = user_delay_ms;
		dev[i].dev_id  =  i;
		rslt = bmp280_init(dev); //reads the chip-id and calibration data from the sensor
		if (rslt == BMP280_OK)
		{
			/* Sensor chip ID will be printed if initialization was successful */
			printf("\nchip id 0x%x ", dev[i].chip_id);
			uart_puts("SUCCESS!");
			_delay_ms(10);
			printf("\r\n");
			printf(" code %d\r\n", rslt);
			//_delay_ms(1000);
			//uart_puts(tbuf);
			sensor_config(dev); 
			printf("\r\n");
			_delay_ms(10);
			//uart_puts("configured");
			printf("\r\n Sensor %d configured, code: %d\r\n", i, rslt);
			_delay_ms(100);
		}
		else
		{
			uart_puts("FAIL: ");
			printf("\r\n Sensor %d returned error code %d\r\n", i, rslt);
			_delay_ms(500);
		}
	}
}

void user_delay_ms(uint32_t period)
{
	for (int i=0;i<period;i++)
	_delay_ms(1);
}

void sensor_config(struct bmp280_dev *dev)
{
	/* Always read the current settings before writing, especially when
	 * all the configuration is not modified 
	 */
	int8_t rslt;
	rslt = bmp280_get_config(&conf, dev);
	/* Check if rslt == BMP280_OK, if not, then handle accordingly */
	if (rslt == BMP280_OK)
	{
		rslt = bmp280_set_power_mode(BMP280_NORMAL_MODE, dev); //200628
	/* Overwrite the desired settings */
		conf.filter = BMP280_FILTER_COEFF_16;
		conf.os_pres = BMP280_OS_16X;
		conf.os_temp = BMP280_OS_2X;
		conf.odr = BMP280_ODR_500_MS;
	}
	rslt = bmp280_set_config(&conf, dev);

	_delay_ms(2);
	/* Check if rslt == BMP280_OK, if not, then handle accordingly */
	if (rslt !=BMP280_OK)
	{
		printf("set config FAIL: %d/r/n",rslt);
		_delay_ms(500);
	}
	/* Always set the power mode after setting the configuration */
	rslt = bmp280_set_power_mode(BMP280_NORMAL_MODE, dev);
	_delay_ms(2);
	uart_puts("spwr");
	if (rslt !=BMP280_OK)
	{
		printf("set power FAIL: %d/r/n",rslt);
		_delay_ms(500);
	}
	else
	{
		//printf("sensor config: %d/r/n",rslt);
	}
}

void cs_low(uint8_t dev_id)
{
	if (dev_id == 0)
	{
		PORTB &= ~(1 << 0); // Pin 0 goes low
	}
	else if (dev_id == 1)
	{
		PORTE &= ~(1 << 7); // Pin 7 goes low
	}
}
void cs_high(uint8_t dev_id)
{
	if (dev_id == 0)
	{
		PORTB |= (1 << 0); // Pin 0 goes high
	}
	else if (dev_id == 1)
	{
		PORTE |= (1 << 7); // Pin 7 goes high
	}
}

int8_t user_spi_read(uint8_t dev_id, uint8_t reg_addr, uint8_t *reg_data, uint16_t len)
{
    int8_t rslt = 0; /* Return 0 for Success, non-zero for failure */
	int8_t cnt = 0;

    /*
     * The parameter dev_id can be used as a variable to select which Chip Select pin has
     * to be set low to activate the relevant device on the SPI bus
     */

    /*
     * Data on the bus should be like
     * |----------------+---------------------+-------------|
     * | MOSI           | MISO                | Chip Select |
     * |----------------+---------------------|-------------|
     * | (don't care)   | (don't care)        | HIGH        |
     * | (reg_addr)     | (don't care)        | LOW         |
     * | (don't care)   | (reg_data[0])       | LOW         |
     * | (....)         | (....)              | LOW         |
     * | (don't care)   | (reg_data[len - 1]) | LOW         |
     * | (don't care)   | (don't care)        | HIGH        |
     * |----------------+---------------------|-------------|
     */
	cs_low(dev_id);

	SPI_transmit(reg_addr);
	//sprintf(tbuf,"address: %d\r\n",reg_addr);
	//uart_puts(tbuf);
	do
	{
		*reg_data = (uint8_t)SPI_receive();	
		//uint8_t data = *reg_data;
		//sprintf(tbuf,"data: %d\r\n",data);
		//uart_puts(tbuf);
		reg_data ++;
		cnt++;
	}while (len > cnt);
	//rslt = 1;
    cs_high(dev_id);
	//_delay_ms(10);
    return rslt;
}

int8_t user_spi_write(uint8_t dev_id, uint8_t reg_addr, uint8_t *reg_data, uint16_t len)
{
    /*
     * The parameter dev_id can be used as a variable to select which Chip Select pin has
     * to be set low to activate the relevant device on the SPI bus
     */
		
    /*
     * Data on the bus should be like
     * |---------------------+--------------+-------------|
     * | MOSI                | MISO         | Chip Select |
     * |---------------------+--------------|-------------|
     * | (don't care)        | (don't care) | HIGH        |
     * | (reg_addr)          | (don't care) | LOW         |
     * | (reg_data[0])       | (don't care) | LOW         |
     * | (....)              | (....)       | LOW         |
     * | (reg_data[len - 1]) | (don't care) | LOW         |
     * | (don't care)        | (don't care) | HIGH        |
     * |---------------------+--------------|-------------|
     */
    int8_t rslt = 0; /* Return 0 for Success, non-zero for failure */
	uint8_t cnt = 0;
	cs_low(dev_id);
	//_delay_ms(10);
	SPI_transmit(reg_addr);
	do 
	{
		SPI_transmit(reg_data[cnt]);
		cnt++;
	}while (len > cnt);
	cs_high(dev_id);
    return rslt;
}

void BMP280_getMeasurement(struct bmp280_dev *dev)
{
	int8_t rslt;
	int32_t temp32; //200628
	uint32_t pres32; //200628
	uint8_t meas_dur;
	struct bmp280_uncomp_data ucomp_data;
	struct bmp280_calib_param cal_param;
	
	for (uint8_t i = 0; i < DEVICES; i++){
		meas_dur = bmp280_compute_meas_time(dev);
		dev[i].delay_ms(meas_dur); /* Measurement time */
		rslt = bmp280_get_uncomp_data(&ucomp_data, dev);
		rslt = bmp280_get_comp_temp_32bit(&temp32, ucomp_data.uncomp_temp, dev); // 200628
//		int32_t temp32 = bmp280_get_comp_temp_32bit(ucomp_data.uncomp_temp, dev);  200628
		rslt = bmp280_get_comp_pres_32bit(&pres32, ucomp_data.uncomp_press, dev); // 200628
//		uint32_t pres32 = bmp280_get_comp_pres_32bit(ucomp_data.uncomp_press, dev);  200628
//		uint32_t pres64 = bmp280_get_comp_pres_64bit(ucomp_data.uncomp_press, dev);  200628
//		double temp = bmp280_get_comp_temp_double(ucomp_data.uncomp_temp, dev);  200628
//		double pres = bmp280_get_comp_pres_double(ucomp_data.uncomp_press, dev);  200628
		char resString[300];
//		sprintf(resString, "Sensor %d UT: %ld, UP: %ld, T32: %ld, P32: %ld\r\n", \
		dev[i].dev_id, ucomp_data.uncomp_temp, ucomp_data.uncomp_press, temp32, pres32);
		sprintf(resString, "Sensor %d UT: %ld\r\n", dev[i].dev_id, ucomp_data.uncomp_temp);
		uart_puts(resString);
		dev[i].delay_ms(50);
	}
	
	
		
	/*Get the duration for 1 sample.*/
	//      meas_dur = bmp280_compute_meas_time(dev);
	
	/* Loop to read out 10 samples of data */
	//for (uint8_t i = 0; (i < 10) && (rslt == BMP280_OK); i++) {
		       //bmp.delay_ms(meas_dur); /* Measurement time */	
		//      rslt = bmp280_get_uncomp_data(&ucomp_data, dev);
		//bmp.delay_ms(meas_dur); /* Measurement time */;
		/* Check if rslt == BMP280_OK, if not, then handle accordingly */
		//printf(" code %d\r\n", rslt);
/*		uint8_t t1 = cal_param.dig_t1;
		printf(" t1: %u\r\n", t1);
		_delay_ms(100);
		uint8_t t2 = cal_param.dig_t2;
		printf(" t2: %u\r\n", t2);
		_delay_ms(100);
		uint8_t t3 = cal_param.dig_t3;
		printf(" t3: %u\r\n", t3);
		_delay_ms(100);
		uint8_t p1 = cal_param.dig_p1;
		printf(" p1: %u\r\n", p1);
		_delay_ms(100);
		uint8_t p2 = cal_param.dig_p2;
		printf(" p2: %u\r\n", p2);
		_delay_ms(100);
		uint8_t p3 = cal_param.dig_p3;
		printf(" p3: %u\r\n", p3); 
		_delay_ms(100); */
		uint32_t tfine = cal_param.t_fine;
		printf(" tfine: %u\r\n", tfine); 
}


void port_init(void)
{

	PORTA = 0x00;
	DDRA  = 0x00;
	PORTB = 0x00;             //pull-up on for pushbutton
	DDRB  = 0x00;
	DDRE = 0b11111010;
}
void system_init(void)
{
	stdout = &mystdout; //Required for printf init
	port_init();
	spi_init();
	USART_Init(BAUDRATE);
	uart_puts("BMP280 start...");             //inti UART with 9600 baud rate with XTAL 16Mhz
    init_bmp280(bmp);
	//while(1);
}
int main(void)
{
    /* Replace with your application code */
	for (uint8_t  i= 0 ; i < 100; i++){
		_delay_ms(100);
	}		
	system_init();
	uart_puts("BMP280 is ok...");
	_delay_ms(500);
    while (1) 
    {
		//for (uint8_t i = 0; i < DEVICES; i++)
		//{
			//bmp.dev_id  =  i;
			BMP280_getMeasurement(bmp);
			_delay_ms(1000);
		//}
    }
}