/*******************************************************************************
* Copyright (C), 2000-2016,  Electronic Technology Co., Ltd.
* FileName: AS23F.c
* Author: 
* Version:
* Date: 
* Description:Define the operation interface of AS23F
* History:
*    1. Date: 
*       Author: 
*       Modification: 
*    2. Date：
		Author：
		Modification：
* Others:
*******************************************************************************/
#ifndef AS23F_C
#define AS23F_C

#include "AS23F.h"
#include "myiic.h"
#include "math.h"
#include "sys.h"
#include "usart.h"		
#include "delay.h"	
#include "led.h"
static struct AS23F_t AS23F;
static struct AS23F_t *p_AS23F;

void AS23F_write(uint8_t hwadr, uint8_t regadr, uint8_t val);
uint8_t AS23F_read(uint8_t hwadr, uint8_t regadr);
void AS23F_get_calib_param(void);

/*****************************************************************************
 Function: AS23F_write
 Description: this function will write data to specofic register through software I2C bus
 Input:  uint8_t hwadr   hardware I2C address
         uint8_t regadr  register address
         uint8_t val     write-in value
 Output:
 Return:
 Calls:
 Called By:
*****************************************************************************/
void AS23F_write(uint8_t hwadr, uint8_t regadr, uint8_t val)
{
    IIC_Start();
    IIC_Send_Byte(hwadr << 1);
	  IIC_Wait_Ack();
    IIC_Send_Byte(regadr);
	  IIC_Wait_Ack();
    IIC_Send_Byte(val);
	  IIC_Wait_Ack();
    IIC_Stop();
}

/*****************************************************************************
 Function: AS23F_read
 Description: this function will read register data through software I2C bus
 Input: uint8_t hwadr   hardware I2C address
        uint8_t regadr  register address
 Output:
 Return: uint8_t readout value
 Calls:
 Called By:
*****************************************************************************/
uint8_t AS23F_read(uint8_t hwadr, uint8_t regadr)
{
    uint8_t val = 0;
    IIC_Start();
    IIC_Send_Byte(hwadr << 1);
	  IIC_Wait_Ack();
    IIC_Send_Byte(regadr);
	  IIC_Wait_Ack();
    IIC_Start();
    IIC_Send_Byte((hwadr << 1)|0x01);
	  IIC_Wait_Ack();
    val = IIC_Read_Byte(0);
    IIC_Stop();
    return val;
}

/*****************************************************************************
 Function: AS23F_init
 Description: initialization
 Input: void
 Output:
 Return: void
 Calls:
 Called By:
*****************************************************************************/
void AS23F_init(void)
{
    p_AS23F = &AS23F; /* read Chip Id */
    p_AS23F->i32rawPressure = 0;
    p_AS23F->i32rawTemperature = 0;
    p_AS23F->chip_id = 0x34;
    AS23F_get_calib_param();
    // sampling rate = 1Hz; Pressure oversample = 2;
    AS23F_rateset(PRESSURE_SENSOR,32, 8);
    // sampling rate = 1Hz; Temperature oversample = 1;
    AS23F_rateset(TEMPERATURE_SENSOR,32, 8);
    //Start background measurement
    printf("AS23F-C0(Pa): %d\r\n",p_AS23F->calib_param.c0);
	  printf("AS23F-C1(C): %d\r\n",p_AS23F->calib_param.c1);
	  printf("AS23F-C00(C): %d\r\n",p_AS23F->calib_param.c00);
	  printf("AS23F-C10(C): %d\r\n",p_AS23F->calib_param.c10);
	  printf("AS23F-C01(C): %d\r\n",p_AS23F->calib_param.c01);
	  printf("AS23F-C11(C): %d\r\n",p_AS23F->calib_param.c11);
	  printf("AS23F-C20(C): %d\r\n",p_AS23F->calib_param.c20);
	  printf("AS23F-C21(C): %d\r\n",p_AS23F->calib_param.c21);
	  printf("AS23F-C30(C): %d\r\n",p_AS23F->calib_param.c30);
}

/*****************************************************************************
 Function: AS23F_rateset
 Description: set sample rate and over sample rate per second for specific sensor
 Input:     uint8_t u8OverSmpl  oversample rate         Maximal = 128
            uint8_t u8SmplRate  sample rate(Hz) Maximal = 128
            uint8_t iSensor     0: Pressure; 1: Temperature
 Output:
 Return: void
 Calls:
 Called By:
*****************************************************************************/
void AS23F_rateset(uint8_t iSensor, uint8_t u8SmplRate, uint8_t u8OverSmpl)
{
    uint8_t reg = 0;
    int32_t i32kPkT = 0;
    switch(u8SmplRate)
    {
        case 2:
            reg |= (1<<4);
            break;
        case 4:
            reg |= (2<<4);
            break;
        case 8:
            reg |= (3<<4);
            break;
        case 16:
            reg |= (4<<4);
            break;
        case 32:
            reg |= (5<<4);
            break;
        case 64:
            reg |= (6<<4);
            break;
        case 128:
            reg |= (7<<4);
            break;
        case 1:
        default:
            break;
    }
    switch(u8OverSmpl)
    {
        case 2:
            reg |= 1;
            i32kPkT = 1572864;
            break;
        case 4:
            reg |= 2;
            i32kPkT = 3670016;
            break;
        case 8:
            reg |= 3;
            i32kPkT = 7864320;
            break;
        case 16:
            i32kPkT = 253952;
            reg |= 4;
            break;
        case 32:
            i32kPkT = 516096;
            reg |= 5;
            break;
        case 64:
            i32kPkT = 1040384;
            reg |= 6;
            break;
        case 128:
            i32kPkT = 2088960;
            reg |= 7;
            break;
        case 1:
        default:
            i32kPkT = 524288;
            break;
    }

    if(iSensor == PRESSURE_SENSOR)
    {
        p_AS23F->i32kP = i32kPkT;
        AS23F_write(HW_ADR, 0x06, reg);
        if(u8OverSmpl > 8)
        {
            reg = AS23F_read(HW_ADR, 0x09);
            AS23F_write(HW_ADR, 0x09, reg | 0x04);
        }
        else
        {
            reg = AS23F_read(HW_ADR, 0x09);
            AS23F_write(HW_ADR, 0x09, reg & (~0x04));
        }
    }
    if(iSensor == TEMPERATURE_SENSOR)
    {
        p_AS23F->i32kT = i32kPkT;
        AS23F_write(HW_ADR, 0x07, reg|0x80);  //Using mems temperature
        if(u8OverSmpl > 8)
        {
            reg = AS23F_read(HW_ADR, 0x09);
            AS23F_write(HW_ADR, 0x09, reg | 0x08);
        }
        else
        {
            reg = AS23F_read(HW_ADR, 0x09);
            AS23F_write(HW_ADR, 0x09, reg & (~0x08));
        }
    }

}

/*****************************************************************************
 Function: AS23F_get_calib_param
 Description: obtain the calibrated coefficient
 Input: void
 Output:
 Return: void
 Calls:
 Called By:
*****************************************************************************/
void AS23F_get_calib_param(void)
{
    u32 h;
    u32 m;
    u32 l;
    h =  AS23F_read(HW_ADR, 0x10);
    l  =  AS23F_read(HW_ADR, 0x11);
    p_AS23F->calib_param.c0 = (int16_t)h<<4 | l>>4;
    p_AS23F->calib_param.c0 = (p_AS23F->calib_param.c0&0x0800)?(0xF000|p_AS23F->calib_param.c0):p_AS23F->calib_param.c0;
    h =  AS23F_read(HW_ADR, 0x11);
    l  =  AS23F_read(HW_ADR, 0x12);
    p_AS23F->calib_param.c1 = (int16_t)(h&0x0F)<<8 | l;
    p_AS23F->calib_param.c1 = (p_AS23F->calib_param.c1&0x0800)?(0xF000|p_AS23F->calib_param.c1):p_AS23F->calib_param.c1;
    h =  AS23F_read(HW_ADR, 0x13);
    m =  AS23F_read(HW_ADR, 0x14);
    l =  AS23F_read(HW_ADR, 0x15);
    p_AS23F->calib_param.c00 = (int32_t)h<<12 | (int32_t)m<<4 | (int32_t)l>>4;
    p_AS23F->calib_param.c00 = (p_AS23F->calib_param.c00&0x080000)?(0xFFF00000|p_AS23F->calib_param.c00):p_AS23F->calib_param.c00;
    h =  AS23F_read(HW_ADR, 0x15);
    m =  AS23F_read(HW_ADR, 0x16);
    l =  AS23F_read(HW_ADR, 0x17);
    p_AS23F->calib_param.c10 = (int32_t)(h&0x0F)<<16 | (int32_t)m<<8 | l;
    p_AS23F->calib_param.c10 = (p_AS23F->calib_param.c10&0x080000)?(0xFFF00000|p_AS23F->calib_param.c10):p_AS23F->calib_param.c10;
    h =  AS23F_read(HW_ADR, 0x18);
    l  =  AS23F_read(HW_ADR, 0x19);
    p_AS23F->calib_param.c01 = (int16_t)h<<8 | l;
    h =  AS23F_read(HW_ADR, 0x1A);
    l  =  AS23F_read(HW_ADR, 0x1B);
    p_AS23F->calib_param.c11 = (int16_t)h<<8 | l;
    h =  AS23F_read(HW_ADR, 0x1C);
    l  =  AS23F_read(HW_ADR, 0x1D);
    p_AS23F->calib_param.c20 = (int16_t)h<<8 | l;
    h =  AS23F_read(HW_ADR, 0x1E);
    l  =  AS23F_read(HW_ADR, 0x1F);
    p_AS23F->calib_param.c21 = (int16_t)h<<8 | l;
    h =  AS23F_read(HW_ADR, 0x20);
    l  =  AS23F_read(HW_ADR, 0x21);
    p_AS23F->calib_param.c30 = (int16_t)h<<8 | l;
}

/*****************************************************************************
 Function: AS23F_start_temperature
 Description: start one measurement for temperature
 Input: void
 Output:
 Return: void
 Calls:
 Called By:
*****************************************************************************/
void AS23F_start_temperature(void)
{
    AS23F_write(HW_ADR, 0x08, 0x02);
}

/*****************************************************************************
 Function: AS23F_start_pressure
 Description: start one measurement for pressure
 Input: void
 Output:
 Return: void
 Calls:
 Called By:
*****************************************************************************/

void AS23F_start_pressure(void)
{
    AS23F_write(HW_ADR, 0x08, 0x01);
}
/*****************************************************************************
 Function: AS23F_start_continuous
 Description: Select mode for the continuously measurement
 Input: uint8_t mode  1: pressure; 2: temperature; 3: pressure and temperature
 Output:
 Return: void
 Calls:
 Called By:
*****************************************************************************/
void AS23F_start_continuous(uint8_t mode)
{
    AS23F_write(HW_ADR, 0x08, mode+4);
}

void AS23F_stop(void)
{
    AS23F_write(HW_ADR, 0x08, 0);
}

/*****************************************************************************
 Function: AS23F_get_raw_temp
 Description:obtain the original temperature value and turn them into 32bits-integer
 Input: void
 Output:
 Return: void
 Calls:
 Called By:
*****************************************************************************/
void AS23F_get_raw_temp(void)
{
    uint8_t h,m,l;
    IIC_Start();
	  IIC_Send_Byte(HW_ADR << 1);
	  IIC_Wait_Ack();
    /*if(IIC_Send_Byte(HW_ADR << 1))
    {return 1;
    }*/
    IIC_Send_Byte(0x03);
	  IIC_Wait_Ack();
    IIC_Start();
    IIC_Send_Byte((HW_ADR << 1)|0x01);
	  IIC_Wait_Ack();
    h = IIC_Read_Byte(1);
    m = IIC_Read_Byte(1);
    l = IIC_Read_Byte(0);
    IIC_Stop();
    p_AS23F->i32rawTemperature = (int32_t)h<<16 | (int32_t)m<<8 | (int32_t)l;
    p_AS23F->i32rawTemperature = (p_AS23F->i32rawTemperature&0x800000) ? (0xFF000000|p_AS23F->i32rawTemperature) : p_AS23F->i32rawTemperature;
    //return 0;
}

/*****************************************************************************
 Function: AS23F_get_raw_pressure
 Description: obtain the original pressure value and turn them into 32bits-integer
 Input: void
 Output:
 Return: void
 Calls:
 Called By:
*****************************************************************************/
void AS23F_get_raw_pressure(void)
{
    uint8_t h,m,l;
    IIC_Start();
    IIC_Send_Byte(HW_ADR << 1);
	  IIC_Wait_Ack();
    IIC_Send_Byte(0x00);
	  IIC_Wait_Ack();
    IIC_Start();
    IIC_Send_Byte((HW_ADR << 1)|0x01);
	  IIC_Wait_Ack();
    h = IIC_Read_Byte(1);
    m = IIC_Read_Byte(1);
    l = IIC_Read_Byte(0);
    IIC_Stop();

    p_AS23F->i32rawPressure = (int32_t)h<<16 | (int32_t)m<<8 | (int32_t)l;
    p_AS23F->i32rawPressure= (p_AS23F->i32rawPressure&0x800000) ? (0xFF000000|p_AS23F->i32rawPressure) : p_AS23F->i32rawPressure;
}

/*****************************************************************************
 Function: AS23F_get_temperature
 Description:  return calibrated temperature value base on original value.
 Input: void
 Output:
 Return: void
 Calls:
 Called By:
*****************************************************************************/
float AS23F_get_temperature(void)
{
    float fTCompensate;
    float fTsc;

    fTsc = p_AS23F->i32rawTemperature / (float)p_AS23F->i32kT;
    fTCompensate =  p_AS23F->calib_param.c0 * 0.5 + p_AS23F->calib_param.c1 * fTsc;
    return fTCompensate;
}

/*****************************************************************************
 Function: AS23F_get_pressure
 Description: return calibrated pressure value base on original value.
 Input: void
 Output:
 Return: void
 Calls:
 Called By:
*****************************************************************************/

float AS23F_get_pressure(void)
{
    float fTsc, fPsc;
    float qua2, qua3;
    float fPCompensate;

    fTsc = p_AS23F->i32rawTemperature / (float)p_AS23F->i32kT;
    fPsc = p_AS23F->i32rawPressure / (float)p_AS23F->i32kP;
    qua2 = p_AS23F->calib_param.c10 + fPsc * (p_AS23F->calib_param.c20 + fPsc* p_AS23F->calib_param.c30);
    qua3 = fTsc * fPsc * (p_AS23F->calib_param.c11 + fPsc * p_AS23F->calib_param.c21);

    fPCompensate = p_AS23F->calib_param.c00 + fPsc * qua2 + fTsc * p_AS23F->calib_param.c01 + qua3;
    return fPCompensate;
}

void Read_AS23F(void)
{
	//u8 Status = 0x00;
	float AS23Fpdata,AS23Ftdata;
	//u8 Dev_add = 0x77<<1;
  AS23F_init();
	
  // sampling rate = 32Hz; Pressure oversample = 8;
  AS23F_rateset(PRESSURE_SENSOR,32, 8);   
  // sampling rate = 32Hz; Temperature oversample = 8; 
  AS23F_rateset(TEMPERATURE_SENSOR,32, 8);
	AS23F_start_continuous(CONTINUOUS_P_AND_T);
	
	//AS23F_start_temperature();
	//AS23F_start_pressure();
	
	AS23F_get_raw_temp();
	AS23F_get_raw_pressure();
	
	AS23Fpdata = AS23F_get_pressure();
	AS23Ftdata = AS23F_get_temperature();
	printf("AS23F-PressData(Pa): %.2f\r\n",AS23Fpdata);
	printf("AS23F-TempData(C): %.2f\r\n",AS23Ftdata);
}


#endif