Merge branch '安邦测距手环' of http://47.108.70.204:60062/r/ChinaUWBProject into ...

yincheng.zhong

2024-08-27 fc78430a35be252a1cd5a29b5b66290a68cd9ca3

 keil/include/drivers/lis3dh_driver.c

@@ -5,7 +5,7 @@
* Version            : $Revision:$
* Date               : $Date:$
* Description        : LIS3DH driver file
*                      
*
* HISTORY:
* Date               |   Modification                    |   Author
* 24/06/2011         |   Initial Revision                |   Fabio Tota
@@ -40,16 +40,16 @@

//int main(void)
//{
//   delay_init();           //延时函数初始化	
//   delay_init();           //延时函数初始化
//   uart_init(115200);       //串口初始化为115200
//   IIC2_Init();
//   delay_ms(100);
//   while(1)
//   {
//      LIS3DH_Data_Init();	
//      delay_ms(1000);	
//   }	
//	
//      LIS3DH_Data_Init();
//      delay_ms(1000);
//   }
//
//}


@@ -58,7 +58,7 @@
#define ARM_BIT_8               0

#if ARM_BIT_8
//如下数据类型是在8位机上定义的，在其它平台（比如32位）可能存在差别，需要根据实际情况修改 。 
//如下数据类型是在8位机上定义的，在其它平台（比如32位）可能存在差别，需要根据实际情况修改 。
typedef unsigned char    u8_m;                   /* 无符号8位整型变量*/
typedef signed   char    s8_m;                   /* 有符号8位整型变量*/
typedef unsigned int     u16_m;                  /* 无符号16位整型变量*/
@@ -68,7 +68,7 @@
typedef float            fp32_m;                 /* 单精度浮点数（32位长度）*/
typedef double           fp64_m;                 /* 双精度浮点数（64位长度）*/
#else
//如下数据类型是在32位机上定义的，在其它平台（比如8位）可能存在差别，需要根据实际情况修改 。 
//如下数据类型是在32位机上定义的，在其它平台（比如8位）可能存在差别，需要根据实际情况修改 。
typedef unsigned char    u8_m;                   /* 无符号8位整型变量*/
typedef signed   char    s8_m;                   /* 有符号8位整型变量*/
typedef unsigned short   u16_m;                  /* 无符号16位整型变量*/
@@ -139,82 +139,82 @@

s8_m mir3da_register_read(u8_m ReadAddr, u8_m *data_m, u8_m Len)
{
		 				 
   mir3da_ReadOneByte(ReadAddr);
	

    mir3da_ReadOneByte(ReadAddr);

}

s8_m mir3da_register_write(u8_m ReadAddr, u8_m data_m)
{
	
   mir3da_WriteOneByte(ReadAddr,data_m);
	

    mir3da_WriteOneByte(ReadAddr,data_m);

}

s8_m mir3da_register_mask_write(u8_m ReadAddr, u8_m mask, u8_m data)
{
    int res=0;
    unsigned char tmp_data=0;
	

    res = mir3da_register_read(ReadAddr, &tmp_data, 1);
    tmp_data &= ~mask; 
    tmp_data &= ~mask;
    tmp_data |= data & mask;
    res |= mir3da_register_write(ReadAddr, tmp_data);
  

    return 0;
}


//void delay_us(uint32_t nTimer)  
//{  
//    uint32_t i=0;  
//    for(i=0;i<nTimer;i++){  
//void delay_us(uint32_t nTimer)
//{
//    uint32_t i=0;
//    for(i=0;i<nTimer;i++){
//        __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
//      __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
//      __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();  
//      __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
//        __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
//      __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
//      __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();  
//        __NOP();__NOP();__NOP();__NOP(); 
//    }  
//      __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
//        __NOP();__NOP();__NOP();__NOP();
//    }
//}
AxesRaw_t lis2dhdata;

//OLED初始化IIC
uint8_t t11;
void IIC2_Init(void)
{					     
{
//   GPIO_InitTypeDef GPIO_InitStructure= {0};
// __HAL_RCC_GPIOA_CLK_ENABLE();
//	
//
//   GPIO_InitStructure.Pin = GPIO_PIN_2|GPIO_PIN_3;
//   GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_OD ;   //开漏输出
//   GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;
//   HAL_GPIO_Init(GPIOA, &GPIO_InitStructure);
//   HAL_GPIO_WritePin(GPIOA,GPIO_PIN_2|GPIO_PIN_3,GPIO_PIN_SET);    //PB6,PB7 输出高
	
      //IIC引脚MK配置PIN10 SDA ,PIN11 SCL

    //IIC引脚MK配置PIN10 SDA ,PIN11 SCL
    io_pin_mux_set(SDA_PIN, IO_FUNC0);
    io_pin_mux_set(SCL_PIN, IO_FUNC0);
		
      gpio_pin_set_dir(SDA_PIN , GPIO_DIR_OUT, 1);

    gpio_pin_set_dir(SDA_PIN , GPIO_DIR_OUT, 1);
//      io_open_drain_set(SDA_PIN, 1);
        io_pull_set(SDA_PIN , IO_PULL_UP, IO_PULL_UP_LEVEL2);//输出高阻态
		
      gpio_pin_set_dir(SCL_PIN , GPIO_DIR_OUT, 1);
      //io_open_drain_set(SCL_PIN, 1);//设置开漏输出
        io_pull_set(SCL_PIN , IO_HIGH_Z, IO_PULL_UP_NONE);
    io_pull_set(SDA_PIN , IO_PULL_UP, IO_PULL_UP_LEVEL2);//输出高阻态

    gpio_pin_set_dir(SCL_PIN , GPIO_DIR_OUT, 1);
    //io_open_drain_set(SCL_PIN, 1);//设置开漏输出
    io_pull_set(SCL_PIN , IO_HIGH_Z, IO_PULL_UP_NONE);
}

uint8_t lisid;
uint8_t lisidtemp;

void Accelerometer_Init()    
void Accelerometer_Init()
{

    LIS3DH_GetWHO_AM_I(&lisidtemp);  
    LIS3DH_GetWHO_AM_I(&lisidtemp);
    lisid=(uint16_t)lisidtemp;
    

    if(lisid == 0x33)
    {
        LIS3DH_Data_Init();
@@ -226,127 +226,127 @@

}

void mir3da_init()	
void mir3da_init()
{
   u8_m data_m = 0;
   int i;
   int threshold = 0;
	
	
   //softreset
   mir3da_register_write(REG_SPI_CONFIG, 0x24);
   delay_us(20000);
    u8_m data_m = 0;
    int i;
    int threshold = 0;

   mir3da_register_write(REG_RESOLUTION_RANGE, 0x00);   //0x0F; +/-2G,14bit
   mir3da_register_write(REG_ODR_AXIS, 0x05);         //0x10; ODR=31.25hz(step counter minimum ODR)
   mir3da_register_write(REG_MODE_BW, 0x04);         //0x11; suspend mode, osr=1x, bw=1/10odr, autosleep disable

   //load_offset_from_filesystem(offset_x, offset_y, offset_z);   //pseudo-code
	
   //private register, just do it.
   mir3da_register_write(0x7F, 0x83);
   mir3da_register_write(0x7F, 0x69);
   mir3da_register_write(0x7F, 0xBD);
    //softreset
    mir3da_register_write(REG_SPI_CONFIG, 0x24);
    delay_us(20000);

   //don't pull up sd0 pin
   if(i2c_addr == 0x26){
      mir3da_register_mask_write(0x8C, 0x40, 0x00);
   }
    mir3da_register_write(REG_RESOLUTION_RANGE, 0x00);   //0x0F; +/-2G,14bit
    mir3da_register_write(REG_ODR_AXIS, 0x05);         //0x10; ODR=31.25hz(step counter minimum ODR)
    mir3da_register_write(REG_MODE_BW, 0x04);         //0x11; suspend mode, osr=1x, bw=1/10odr, autosleep disable

   mir3da_set_active_interrupt_enable(1);
	
   g_com_map[IMU_THRES]=0x14;
    //load_offset_from_filesystem(offset_x, offset_y, offset_z);   //pseudo-code

    //private register, just do it.
    mir3da_register_write(0x7F, 0x83);
    mir3da_register_write(0x7F, 0x69);
    mir3da_register_write(0x7F, 0xBD);

    //don't pull up sd0 pin
    if(i2c_addr == 0x26) {
        mir3da_register_mask_write(0x8C, 0x40, 0x00);
    }

    mir3da_set_active_interrupt_enable(1);

    g_com_map[IMU_THRES]=0x14;
//   LIS3DH_WriteReg(LIS3DH_INT1_THS, (uint8_t)g_com_map[IMU_THRES]);     /* INT1_THS(32h): ?????? 0x10: 16*2(FS)  0x20: 32*16(FS) */
   mir3da_register_write(REG_ACTIVE_THS,(uint8_t)g_com_map[IMU_THRES]);
	
   delay_us(10); 
	
   mir3da_set_enable(1);
	
   mir3da_set_step_counter_open(1);
    mir3da_register_write(REG_ACTIVE_THS,(uint8_t)g_com_map[IMU_THRES]);

    delay_us(10);

    mir3da_set_enable(1);

    mir3da_set_step_counter_open(1);

}


void LIS3DH_Data_Init()	
void LIS3DH_Data_Init()
{
   //uint8_t buffer[26]; 
	
   uint8_t response;
    //uint8_t buffer[26];

    uint8_t response;
//  uint8_t lisidtemp;
	
   LIS3DH_WriteReg(LIS3DH_CTRL_REG1, 0x37);   /* CTRL_REG1(20h): ??sensor,???????? ODR 25HZ */
   LIS3DH_WriteReg(LIS3DH_CTRL_REG2, 0x03);   /* CTRL_REG2(21h): IA1?IA2 ?????? bc */
	
   LIS3DH_WriteReg(LIS3DH_CTRL_REG3, 0x40);   /* CTRL_REG3(22h): 0x80 ???????INT_1 INT_2 */
   LIS3DH_WriteReg(LIS3DH_CTRL_REG4, 0x08);  /* CTRL_REG4(23h): ???,????,???+/-2G,?????? */
   LIS3DH_WriteReg(LIS3DH_INT1_CFG, 0xaa);  /* INT1_CFG(30h): ??,6D X/Y/Z???????? */
   g_com_map[IMU_THRES]=2;
   LIS3DH_WriteReg(LIS3DH_INT1_THS, (uint8_t)g_com_map[IMU_THRES]);     /* INT1_THS(32h): ?????? 0x10: 16*2(FS)  0x20: 32*16(FS) */

    LIS3DH_WriteReg(LIS3DH_CTRL_REG1, 0x37);   /* CTRL_REG1(20h): ??sensor,???????? ODR 25HZ */
    LIS3DH_WriteReg(LIS3DH_CTRL_REG2, 0x03);   /* CTRL_REG2(21h): IA1?IA2 ?????? bc */

    LIS3DH_WriteReg(LIS3DH_CTRL_REG3, 0x40);   /* CTRL_REG3(22h): 0x80 ???????INT_1 INT_2 */
    LIS3DH_WriteReg(LIS3DH_CTRL_REG4, 0x08);  /* CTRL_REG4(23h): ???,????,???+/-2G,?????? */
    LIS3DH_WriteReg(LIS3DH_INT1_CFG, 0xaa);  /* INT1_CFG(30h): ??,6D X/Y/Z???????? */
    g_com_map[IMU_THRES]=2;
    LIS3DH_WriteReg(LIS3DH_INT1_THS, (uint8_t)g_com_map[IMU_THRES]);     /* INT1_THS(32h): ?????? 0x10: 16*2(FS)  0x20: 32*16(FS) */
    LIS3DH_WriteReg(LIS3DH_INT1_DURATION, 0x01);     /* INT1_DURATION(33h): 1LSB=1/ODR  ??ODR=100HZ  ??1LSB=10ms ???? 1s,??100->0x64 */
   /* Start sensor */
   LIS3DH_WriteReg(0x20, 0x5f);  /* CTRL_REG1(20h): Start sensor at ODR 100Hz Low-power mode */
	
	
   // Read ID
   LIS3DH_GetWHO_AM_I(&lisidtemp);  
    /* Start sensor */
    LIS3DH_WriteReg(0x20, 0x5f);  /* CTRL_REG1(20h): Start sensor at ODR 100Hz Low-power mode */


    // Read ID
    LIS3DH_GetWHO_AM_I(&lisidtemp);
//   lisid=(uint16_t)lisidtemp;


	
   //get Acceleration Raw data  

    //get Acceleration Raw data
//   response=LIS3DH_GetAccAxesRaw(&data);
   //print data values
   delay_us(10); 
    //print data values
    delay_us(10);
//   if(response==1)
//   {
//		
//
//      printf("传感器原始值:x=%d, y=%d, z=%d\r\n", lis2dhdata.AXIS_X, lis2dhdata.AXIS_Y, lis2dhdata.AXIS_Z);
//      printf( "处理后的加速度值Accel:[x]%dmg,[y]%dmg,[z]%dmg\r\n", 
//                                                (int16_t)((float)lis2dhdata.AXIS_X*4/65536*1000), 
//                                                (int16_t)((float)lis2dhdata.AXIS_Y*4/65536*1000), 
//      printf( "处理后的加速度值Accel:[x]%dmg,[y]%dmg,[z]%dmg\r\n",
//                                                (int16_t)((float)lis2dhdata.AXIS_X*4/65536*1000),
//                                                (int16_t)((float)lis2dhdata.AXIS_Y*4/65536*1000),
//                                                (int16_t)((float)lis2dhdata.AXIS_Z*4/65536*1000));
//	
//
//   }

}
void LIS3DH_ENTER_STY_Init()	
void LIS3DH_ENTER_STY_Init()
{
   //uint8_t buffer[26]; 
	
   uint8_t response;
  uint8_t lisidtemp;
   //set ODR (turn ON device)
   LIS3DH_SetODR(LIS3DH_ODR_10Hz);
   //set PowerMode 
   LIS3DH_SetMode(LIS3DH_POWER_DOWN);
   //set Fullscale
   LIS3DH_SetFullScale(LIS3DH_FULLSCALE_2);
   LIS3DH_SetInt2Pin(LIS3DH_I1_INT2_ON_PIN_INT1_ENABLE);
    //uint8_t buffer[26];

    uint8_t response;
    uint8_t lisidtemp;
    //set ODR (turn ON device)
    LIS3DH_SetODR(LIS3DH_ODR_10Hz);
    //set PowerMode
    LIS3DH_SetMode(LIS3DH_POWER_DOWN);
    //set Fullscale
    LIS3DH_SetFullScale(LIS3DH_FULLSCALE_2);
    LIS3DH_SetInt2Pin(LIS3DH_I1_INT2_ON_PIN_INT1_ENABLE);
//LIS3DH_SetTriggerInt(LIS3DH_TRIG_INT2);
//   LIS3DH_WriteReg(0x34,0xff);
//   LIS3DH_WriteReg(0x35,0x7f);
//   LIS3DH_WriteReg(0x36,0x20);
   //set axis Enable
   LIS3DH_SetAxis(LIS3DH_X_DISABLE | LIS3DH_Y_DISABLE | LIS3DH_Y_DISABLE);
   // Read ID
   //LIS3DH_GetWHO_AM_I(&lisidtemp);  
    //set axis Enable
    LIS3DH_SetAxis(LIS3DH_X_DISABLE | LIS3DH_Y_DISABLE | LIS3DH_Y_DISABLE);
    // Read ID
    //LIS3DH_GetWHO_AM_I(&lisidtemp);
//   lisid=(uint16_t)lisidtemp;
//   printf("LIS3DH ID: %x \r\n",lisid);
   //get Acceleration Raw data  
    //get Acceleration Raw data
//   response=LIS3DH_GetAccAxesRaw(&data);
   //print data values
   //HAL_Delay(100);yuan
   delay_us(100000);	
    //print data values
    //HAL_Delay(100);yuan
    delay_us(100000);
//   if(response==1)
//   {
//		
//
//      printf("传感器原始值:x=%d, y=%d, z=%d\r\n", lis2dhdata.AXIS_X, lis2dhdata.AXIS_Y, lis2dhdata.AXIS_Z);
//      printf( "处理后的加速度值Accel:[x]%dmg,[y]%dmg,[z]%dmg\r\n", 
//                                                (int16_t)((float)lis2dhdata.AXIS_X*4/65536*1000), 
//                                                (int16_t)((float)lis2dhdata.AXIS_Y*4/65536*1000), 
//      printf( "处理后的加速度值Accel:[x]%dmg,[y]%dmg,[z]%dmg\r\n",
//                                                (int16_t)((float)lis2dhdata.AXIS_X*4/65536*1000),
//                                                (int16_t)((float)lis2dhdata.AXIS_Y*4/65536*1000),
//                                                (int16_t)((float)lis2dhdata.AXIS_Z*4/65536*1000));
//	
//
//   }

}
@@ -354,32 +354,32 @@

//enable/disable the chip
void mir3da_set_enable(int enable)     //开启使能
{ 
   if(enable)
      mir3da_register_mask_write(REG_MODE_BW, 0x80, 0x00);   //power on
   else	
    mir3da_register_mask_write(REG_MODE_BW, 0x80, 0x80);
	
   delay_us(100000);
{
    if(enable)
        mir3da_register_mask_write(REG_MODE_BW, 0x80, 0x00);   //power on
    else
        mir3da_register_mask_write(REG_MODE_BW, 0x80, 0x80);

    delay_us(100000);
}

//Read three axis data, 2g range, counting 12bit, 1G=1000mg=1024lsb
void mir3da_read_raw_data(short *x, short *y, short *z)
{
    u8_m tmp_data[6] = {0};
   
   mir3da_register_read(REG_ACC_X_LSB, tmp_data, 6);

    mir3da_register_read(REG_ACC_X_LSB, tmp_data, 6);

    *x = ((short)(tmp_data[1] << 8 | tmp_data[0]))>> 4;
    *y = ((short)(tmp_data[3] << 8 | tmp_data[2]))>> 4;
    *z = ((short)(tmp_data[5] << 8 | tmp_data[4]))>> 4;	
    *z = ((short)(tmp_data[5] << 8 | tmp_data[4]))>> 4;
}

void mir3da_read_data(short *x, short *y, short *z)
{
    u8_m tmp_data[6] = {0};
   
   mir3da_register_read(REG_ACC_X_LSB, tmp_data, 6);

    mir3da_register_read(REG_ACC_X_LSB, tmp_data, 6);

    *x = ((short)(tmp_data[1] << 8 | tmp_data[0])) >> 4 - offset_x;
    *y = ((short)(tmp_data[3] << 8 | tmp_data[2])) >> 4 - offset_y;
@@ -389,46 +389,46 @@
//open active interrupt
void mir3da_set_active_interrupt_enable(int enable)
{
    if(enable){
      mir3da_register_write(REG_ACTIVE_DUR, 0x00);    //持续时间
    if(enable) {
        mir3da_register_write(REG_ACTIVE_DUR, 0x00);    //持续时间
//      mir3da_register_write(REG_ACTIVE_THS, 0x3);   //阈值
      mir3da_register_write(REG_INT_MAP1, 0x04 );
      mir3da_register_write(REG_INT_SET1, 0x87);		
   }
   else{
        mir3da_register_write(REG_INT_MAP1, 0x04 );
        mir3da_register_write(REG_INT_SET1, 0x87);
    }
    else {
        mir3da_register_write(REG_INT_SET1,0x00 );
        mir3da_register_write(REG_INT_MAP1,0x00 );		
   }
        mir3da_register_write(REG_INT_MAP1,0x00 );
    }
}

void mir3da_set_step_counter_open(int enable)       //开启步数计数
{
   if(enable){
            mir3da_register_write(REG_STEP_CONGIF1, 0x01);
    if(enable) {
        mir3da_register_write(REG_STEP_CONGIF1, 0x01);
        mir3da_register_write(REG_STEP_CONGIF2, 0x62);
        mir3da_register_write(REG_STEP_CONGIF3, 0x46);
        mir3da_register_write(REG_STEP_CONGIF4, 0x32);
        mir3da_register_write(REG_STEP_FILTER,  0xa2);	
   }
   else{
        mir3da_register_write(REG_STEP_FILTER,  0xa2);
    }
    else {
        mir3da_register_write(REG_STEP_FILTER,  0x22);
   }
    }
}

void mir3da_reset_step_counter(void)
{
   mir3da_register_mask_write(REG_RESET_STEP, 0x80, 0x80);	
    mir3da_register_mask_write(REG_RESET_STEP, 0x80, 0x80);
}


u16_m mir3da_get_step()    //获得运动步数
{
   u8_m tmp_data[2] = {0};
    u8_m tmp_data[2] = {0};

   f_step = mir3da_ReadLenByte(REG_STEPS_MSB, 2);
	
   return f_step;
	
    f_step = mir3da_ReadLenByte(REG_STEPS_MSB, 2);

    return f_step;

}

//获取数据
@@ -437,51 +437,51 @@

float drv_lis2dh12_get_angle(void)
{
   float acc_x, acc_y, acc_z,acc_g;
   float angle_x, angle_y, angle_z, angle_xyz;
   int8_t data[6];
   uint8_t i; 
   uint8_t response;
  uint8_t lisidtemp;
   //set ODR (turn ON device)
   LIS3DH_SetODR(LIS3DH_ODR_100Hz);
   //set PowerMode 
   LIS3DH_SetMode(LIS3DH_NORMAL);
   //set Fullscale
   LIS3DH_SetFullScale(LIS3DH_FULLSCALE_2);
   //set axis Enable
   LIS3DH_SetAxis(LIS3DH_X_ENABLE | LIS3DH_Y_ENABLE | LIS3DH_Z_ENABLE);
   // Read ID
   LIS3DH_GetWHO_AM_I(&lisidtemp);
    float acc_x, acc_y, acc_z,acc_g;
    float angle_x, angle_y, angle_z, angle_xyz;
    int8_t data[6];
    uint8_t i;
    uint8_t response;
    uint8_t lisidtemp;
    //set ODR (turn ON device)
    LIS3DH_SetODR(LIS3DH_ODR_100Hz);
    //set PowerMode
    LIS3DH_SetMode(LIS3DH_NORMAL);
    //set Fullscale
    LIS3DH_SetFullScale(LIS3DH_FULLSCALE_2);
    //set axis Enable
    LIS3DH_SetAxis(LIS3DH_X_ENABLE | LIS3DH_Y_ENABLE | LIS3DH_Z_ENABLE);
    // Read ID
    LIS3DH_GetWHO_AM_I(&lisidtemp);
//   lisid=(uint16_t)lisidtemp;
//   printf("LIS3DH ID: %x \r\n",lisid);
   //get Acceleration Raw data  
   response=LIS3DH_GetAccAxesRaw(&lis2dhdata);
   //print data values
   delay_us(10); 
    //get Acceleration Raw data
    response=LIS3DH_GetAccAxesRaw(&lis2dhdata);
    //print data values
    delay_us(10);
//    LIS3DH_GetAccAxesRaw(&lis2dhdata);
//   for (i=0; i<6; i++)
//      drv_lis2dh12_iic_read_byte(0x28 + i, data+i);
   if(response==1)
   {
   /* x, y, z ???? */
   acc_x = abs(lis2dhdata.AXIS_X);
   acc_y = abs(lis2dhdata.AXIS_Y);
   acc_z = abs(lis2dhdata.AXIS_Z);
	
   /* ????? */
   acc_g = sqrt(pow(acc_x, 2) + pow(acc_y, 2) + pow(acc_z, 2));
	
   if (acc_z > acc_g)
      acc_z = acc_g;
    if(response==1)
    {
        /* x, y, z ???? */
        acc_x = abs(lis2dhdata.AXIS_X);
        acc_y = abs(lis2dhdata.AXIS_Y);
        acc_z = abs(lis2dhdata.AXIS_Z);

   /* angle_z/90 = asin(acc_z/acc_g)/p/2 */
   angle_z = asin(acc_z/acc_g) * 2 / 3.14 * 90;
   angle_z = 90 - angle_z;
   if(angle_z < 0)
      angle_z = 0;
   }
   return acc_g;
        /* ????? */
        acc_g = sqrt(pow(acc_x, 2) + pow(acc_y, 2) + pow(acc_z, 2));

        if (acc_z > acc_g)
            acc_z = acc_g;

        /* angle_z/90 = asin(acc_z/acc_g)/p/2 */
        angle_z = asin(acc_z/acc_g) * 2 / 3.14 * 90;
        angle_z = 90 - angle_z;
        if(angle_z < 0)
            angle_z = 0;
    }
    return acc_g;
}


@@ -489,26 +489,26 @@
void IIC2_Start(void)
{
//      IIC2_SDA_OUT();     //sda线输出
      SDA_1;
//      delay_us(10);	
      SCL_1;
    SDA_1;
//      delay_us(10);
      SDA_0;//START:when CLK is high,DATA change form high to low
      delay_us(10);
      SCL_0;//钳住I2C总线，准备发送或接收数据 
}	  
    SCL_1;
//      delay_us(10);
    SDA_0;//START:when CLK is high,DATA change form high to low
    delay_us(10);
    SCL_0;//钳住I2C总线，准备发送或接收数据
}
//产生IIC停止信号
void IIC2_Stop(void)
{
//      IIC2_SDA_OUT();//sda线输出
      SCL_0;
    SCL_0;
//      delay_us(10);
      SDA_0;//STOP:when CLK is high DATA change form low to high
       delay_us(10);
      SCL_1; 
    SDA_0;//STOP:when CLK is high DATA change form low to high
    delay_us(10);
    SCL_1;
//      delay_us(10);
      SDA_1;//发送I2C总线结束信号
      delay_us(10);	
    SDA_1;//发送I2C总线结束信号
    delay_us(10);

}

@@ -518,248 +518,248 @@

uint8_t IIC2_Wait_Ack(void)
{
   uint8_t ucErrTime=0;
    uint8_t ucErrTime=0;
//  IIC2_SDA_IN();      //SDA设置为输入
 gpio_pin_set_dir(SDA_PIN , GPIO_DIR_IN, 1);
    SDA_1;
   delay_us(6);	   
   SCL_1;
   delay_us(6);	
    
   while(IIC2_READ_SDA)
   {
      ucErrTime++;
      if(ucErrTime>250)
      {
         IIC2_Stop();
         return 1;
      }
   }
    gpio_pin_set_dir(SDA_PIN , GPIO_DIR_IN, 1);
    SDA_1;
    delay_us(6);
    SCL_1;
    delay_us(6);

    while(IIC2_READ_SDA)
    {
        ucErrTime++;
        if(ucErrTime>250)
        {
            IIC2_Stop();
            return 1;
        }
    }
    gpio_pin_set_dir(SDA_PIN , GPIO_DIR_OUT, 1);
   SCL_0;//时钟输出0
   return 0;  
} 
    SCL_0;//时钟输出0
    return 0;
}
//产生ACK应答
void IIC2_Ack(void)
{
   SCL_0;
    SCL_0;
//   IIC2_SDA_OUT();
   SDA_0;
   delay_us(10);
   SCL_1;
   delay_us(10);
   SCL_0;
    SDA_0;
    delay_us(10);
    SCL_1;
    delay_us(10);
    SCL_0;
}
//不产生ACK应答		    
//不产生ACK应答
void IIC2_NAck(void)
{
   SCL_0;
    SCL_0;
//   IIC2_SDA_OUT();
   SDA_1;
   delay_us(10);
   SCL_1;
   delay_us(10);
   SCL_0;
    SDA_1;
    delay_us(10);
    SCL_1;
    delay_us(10);
    SCL_0;
}


//IIC发送一个字节,WRITE
//返回从机有无应答
//1，有应答
//0，无应答			  
//0，无应答
void IIC2_Send_Byte(uint8_t txd)
{                        
    uint8_t t;   
{
    uint8_t t;
//      IIC2_SDA_OUT();
      SCL_0;//拉低时钟开始数据传输
    for(t=0;t<8;t++)
    {              
         if((txd&0x80)>>7)
         {
            SDA_1;
         }
         else
         {
            SDA_0;
         }
      txd <<= 1;
      delay_us(10);
      SCL_1;
      delay_us(10);
      SCL_0;
      delay_us(10);
    } 	 
} 
    SCL_0;//拉低时钟开始数据传输
    for(t=0; t<8; t++)
    {
        if((txd&0x80)>>7)
        {
            SDA_1;
        }
        else
        {
            SDA_0;
        }
        txd <<= 1;
        delay_us(10);
        SCL_1;
        delay_us(10);
        SCL_0;
        delay_us(10);
    }
}

//读1个字节，ack=1时，发送ACK，ack=0，发送nACK   
//读1个字节，ack=1时，发送ACK，ack=0，发送nACK
uint8_t IIC2_Read_Byte(unsigned char ack)
{
   unsigned char i,receive=0;
    unsigned char i,receive=0;
//   IIC2_SDA_IN();//SDA设置为输入
    for(i=0;i<8;i++ )
   {
    SCL_0; 
    delay_us(10);
      SCL_1;
    receive<<=1;
    if(IIC2_READ_SDA)receive++;   
      delay_us(5); 
    }					 
    for(i=0; i<8; i++ )
    {
        SCL_0;
        delay_us(10);
        SCL_1;
        receive<<=1;
        if(IIC2_READ_SDA)receive++;
        delay_us(5);
    }
    if (!ack)
        IIC2_NAck();//发送nACK
    else
        IIC2_Ack(); //发送ACK   
        IIC2_Ack(); //发送ACK
    return receive;
}

//在LIS3DH里面的指定地址开始读一字节数据
//ReadAddr   :读出的地址 
//ReadAddr   :读出的地址
//返回值     :读出的数据
uint8_t LIS3DH_ReadOneByte(uint16_t ReadAddr)
{
   uint8_t temp=0;		  	    																 
   IIC2_Start();  
   IIC2_Send_Byte(0X32);        //发送写命令
   IIC2_Wait_Ack();       
   IIC2_Send_Byte(ReadAddr);   //发送读地址
   IIC2_Wait_Ack();	    
   IIC2_Start();  	 	   
   IIC2_Send_Byte(0X33);       //发送读命令，进入接收模式		   
   IIC2_Wait_Ack();	 
   temp=IIC2_Read_Byte(0);		   
   IIC2_Stop();                        //产生一个停止条件	     
   return temp;
    uint8_t temp=0;
    IIC2_Start();
    IIC2_Send_Byte(0X32);        //发送写命令
    IIC2_Wait_Ack();
    IIC2_Send_Byte(ReadAddr);   //发送读地址
    IIC2_Wait_Ack();
    IIC2_Start();
    IIC2_Send_Byte(0X33);       //发送读命令，进入接收模式
    IIC2_Wait_Ack();
    temp=IIC2_Read_Byte(0);
    IIC2_Stop();                        //产生一个停止条件
    return temp;
}
//在LIS3DH指定地址写入一个数据
//WriteAddr  :写入数据的目的地址    
//WriteAddr  :写入数据的目的地址
//DataToWrite:要写入的数据
void LIS3DH_WriteOneByte(uint16_t WriteAddr,uint8_t DataToWrite)
{				   	  	    																 
   IIC2_Start();  
   IIC2_Send_Byte(0X32);       //发送写命令
   IIC2_Wait_Ack();
   IIC2_Send_Byte(WriteAddr);               //发送地址
   IIC2_Wait_Ack();	   	 										  		   
   IIC2_Send_Byte(DataToWrite);     //发送字节							   
   IIC2_Wait_Ack();  		    	   
   IIC2_Stop();//产生一个停止条件 
   delay_us(10);	
			
{
    IIC2_Start();
    IIC2_Send_Byte(0X32);       //发送写命令
    IIC2_Wait_Ack();
    IIC2_Send_Byte(WriteAddr);               //发送地址
    IIC2_Wait_Ack();
    IIC2_Send_Byte(DataToWrite);     //发送字节
    IIC2_Wait_Ack();
    IIC2_Stop();//产生一个停止条件
    delay_us(10);

}
//在AT24CXX里面的指定地址开始写入长度为Len的数据
//该函数用于写入16bit或者32bit的数据.
//WriteAddr  :开始写入的地址  
//WriteAddr  :开始写入的地址
//DataToWrite:数据数组首地址
//Len        :要写入数据的长度2,4
void LIS3DH_WriteLenByte(uint16_t WriteAddr,uint32_t DataToWrite,uint8_t Len)
{  	
   uint8_t t;
   for(t=0;t<Len;t++)
   {
      LIS3DH_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
   }												    
{
    uint8_t t;
    for(t=0; t<Len; t++)
    {
        LIS3DH_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
    }
}

//在AT24CXX里面的指定地址开始读出长度为Len的数据
//该函数用于读出16bit或者32bit的数据.
//ReadAddr   :开始读出的地址 
//ReadAddr   :开始读出的地址
//返回值     :数据
//Len        :要读出数据的长度2,4
uint32_t LIS3DH_ReadLenByte(uint16_t ReadAddr,uint8_t Len)
{  	
   uint8_t t;
   uint32_t temp=0;
   for(t=0;t<Len;t++)
   {
      temp<<=8;
      temp+=LIS3DH_ReadOneByte(ReadAddr+Len-t-1); 	 				   
   }
   return temp;												    
{
    uint8_t t;
    uint32_t temp=0;
    for(t=0; t<Len; t++)
    {
        temp<<=8;
        temp+=LIS3DH_ReadOneByte(ReadAddr+Len-t-1);
    }
    return temp;
}

//在mir3da里面的指定地址开始读一字节数据
//ReadAddr   :读出的地址 
//ReadAddr   :读出的地址
//返回值     :读出的数据
uint8_t mir3da_ReadOneByte(uint16_t ReadAddr)
{
   uint8_t temp=0;		  	    																 
   IIC2_Start();  
   IIC2_Send_Byte(0X4e);        //发送写命令
   IIC2_Wait_Ack();       
   IIC2_Send_Byte(ReadAddr);   //发送读地址
   IIC2_Wait_Ack();	    
   IIC2_Start();  	 	   
   IIC2_Send_Byte(0X4f);       //发送读命令，进入接收模式		   
   IIC2_Wait_Ack();	 
   temp=IIC2_Read_Byte(0);		   
   IIC2_Stop();                        //产生一个停止条件	     
   return temp;
    uint8_t temp=0;
    IIC2_Start();
    IIC2_Send_Byte(0X4e);        //发送写命令
    IIC2_Wait_Ack();
    IIC2_Send_Byte(ReadAddr);   //发送读地址
    IIC2_Wait_Ack();
    IIC2_Start();
    IIC2_Send_Byte(0X4f);       //发送读命令，进入接收模式
    IIC2_Wait_Ack();
    temp=IIC2_Read_Byte(0);
    IIC2_Stop();                        //产生一个停止条件
    return temp;
}
//在mir3da指定地址写入一个数据
//WriteAddr  :写入数据的目的地址    
//WriteAddr  :写入数据的目的地址
//DataToWrite:要写入的数据
void mir3da_WriteOneByte(uint16_t WriteAddr,uint8_t DataToWrite)
{				   	  	    																 
   IIC2_Start();  
   IIC2_Send_Byte(0X4e);       //发送写命令
   IIC2_Wait_Ack();
   IIC2_Send_Byte(WriteAddr);               //发送地址
   IIC2_Wait_Ack();	   	 										  		   
   IIC2_Send_Byte(DataToWrite);     //发送字节							   
   IIC2_Wait_Ack();  		    	   
   IIC2_Stop();//产生一个停止条件 
   delay_us(10);	
			
{
    IIC2_Start();
    IIC2_Send_Byte(0X4e);       //发送写命令
    IIC2_Wait_Ack();
    IIC2_Send_Byte(WriteAddr);               //发送地址
    IIC2_Wait_Ack();
    IIC2_Send_Byte(DataToWrite);     //发送字节
    IIC2_Wait_Ack();
    IIC2_Stop();//产生一个停止条件
    delay_us(10);

}
//在AT24CXX里面的指定地址开始写入长度为Len的数据
//该函数用于写入16bit或者32bit的数据.
//WriteAddr  :开始写入的地址  
//WriteAddr  :开始写入的地址
//DataToWrite:数据数组首地址
//Len        :要写入数据的长度2,4
void mir3da_WriteLenByte(uint16_t WriteAddr,uint32_t DataToWrite,uint8_t Len)
{  	
   uint8_t t;
   for(t=0;t<Len;t++)
   {
      mir3da_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
   }												    
{
    uint8_t t;
    for(t=0; t<Len; t++)
    {
        mir3da_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
    }
}

//在AT24CXX里面的指定地址开始读出长度为Len的数据
//该函数用于读出16bit或者32bit的数据.
//ReadAddr   :开始读出的地址 
//ReadAddr   :开始读出的地址
//返回值     :数据
//Len        :要读出数据的长度2,4
uint32_t bu=0;
uint32_t mir3da_ReadLenByte(uint16_t ReadAddr,int Len)
{  	
   uint8_t t;
   u8_m data[Len];  
  memset(data, 0, Len);  
   for(t=0;t<Len;t++)
   { 	
         data[t] = mir3da_ReadOneByte(ReadAddr+t);
   }
   bu = (data[0] << 8 | data[1])/2;
	
   return bu;												    
{
    uint8_t t;
    u8_m data[Len];
    memset(data, 0, Len);
    for(t=0; t<Len; t++)
    {
        data[t] = mir3da_ReadOneByte(ReadAddr+t);
    }
    bu = (data[0] << 8 | data[1])/2;

    return bu;
}


/*******************************************************************************
* Function Name      : LIS3DH_ReadReg
* Description      : Generic Reading function. It must be fullfilled with either
*         : I2C or SPI reading functions					
*         : I2C or SPI reading functions
* Input         : Register Address
* Output      : Data REad
* Return      : None
*******************************************************************************/
uint8_t LIS3DH_ReadReg(uint8_t Reg, uint8_t* Data) {
  
   //To be completed with either I2c or SPI reading function
   //i.e. *Data = SPI_Mems_Read_Reg( Reg );
   *Data = LIS3DH_ReadOneByte(Reg);
   return 1;

    //To be completed with either I2c or SPI reading function
    //i.e. *Data = SPI_Mems_Read_Reg( Reg );
    *Data = LIS3DH_ReadOneByte(Reg);
    return 1;
}


@@ -772,12 +772,12 @@
* Return      : None
*******************************************************************************/
uint8_t LIS3DH_WriteReg(uint8_t WriteAddr, uint8_t Data) {
  
   //To be completed with either I2c or SPI writing function
   //i.e. SPI_Mems_Write_Reg(WriteAddr, Data);
      LIS3DH_WriteOneByte(WriteAddr,Data);
		
   return 1;

    //To be completed with either I2c or SPI writing function
    //i.e. SPI_Mems_Write_Reg(WriteAddr, Data);
    LIS3DH_WriteOneByte(WriteAddr,Data);

    return 1;
}

/* Private functions ---------------------------------------------------------*/
@@ -789,12 +789,12 @@
* Output         : None
* Return         : Status [value of FSS]
*******************************************************************************/
status_t LIS3DH_GetWHO_AM_I(uint8_t* val){
  
   if( !LIS3DH_ReadReg(LIS3DH_WHO_AM_I, val) )	  
   return MEMS_ERROR;
status_t LIS3DH_GetWHO_AM_I(uint8_t* val) {

   return MEMS_SUCCESS;
    if( !LIS3DH_ReadReg(LIS3DH_WHO_AM_I, val) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}

/*******************************************************************************
@@ -805,11 +805,11 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetStatusAUX(uint8_t* val) {
  
  if( !LIS3DH_ReadReg(LIS3DH_STATUS_AUX, val) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;  

    if( !LIS3DH_ReadReg(LIS3DH_STATUS_AUX, val) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -823,99 +823,99 @@
* Return         : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetStatusAUXBit(uint8_t statusBIT, uint8_t* val) {
  uint8_t value;  
  
  if( !LIS3DH_ReadReg(LIS3DH_STATUS_AUX, &value) )
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_STATUS_AUX, &value) )
        return MEMS_ERROR;

    if(statusBIT == LIS3DH_STATUS_AUX_321OR) {
        if(value &= LIS3DH_STATUS_AUX_321OR) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }

    if(statusBIT == LIS3DH_STATUS_AUX_3OR) {
        if(value &= LIS3DH_STATUS_AUX_3OR) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }

    if(statusBIT == LIS3DH_STATUS_AUX_2OR) {
        if(value &= LIS3DH_STATUS_AUX_2OR) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }

    if(statusBIT == LIS3DH_STATUS_AUX_1OR) {
        if(value &= LIS3DH_STATUS_AUX_1OR) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }

    if(statusBIT == LIS3DH_STATUS_AUX_321DA) {
        if(value &= LIS3DH_STATUS_AUX_321DA) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }

    if(statusBIT == LIS3DH_STATUS_AUX_3DA) {
        if(value &= LIS3DH_STATUS_AUX_3DA) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }

    if(statusBIT == LIS3DH_STATUS_AUX_2DA) {
        if(value &= LIS3DH_STATUS_AUX_2DA) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }

    if(statusBIT == LIS3DH_STATUS_AUX_1DA) {
        if(value &= LIS3DH_STATUS_AUX_1DA) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }
    return MEMS_ERROR;
  
  if(statusBIT == LIS3DH_STATUS_AUX_321OR){
    if(value &= LIS3DH_STATUS_AUX_321OR){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }   
  }
  
  if(statusBIT == LIS3DH_STATUS_AUX_3OR){
    if(value &= LIS3DH_STATUS_AUX_3OR){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }     
  }
  
  if(statusBIT == LIS3DH_STATUS_AUX_2OR){
    if(value &= LIS3DH_STATUS_AUX_2OR){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }    
  }
  
  if(statusBIT == LIS3DH_STATUS_AUX_1OR){
    if(value &= LIS3DH_STATUS_AUX_1OR){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }   
  }
  
  if(statusBIT == LIS3DH_STATUS_AUX_321DA){
    if(value &= LIS3DH_STATUS_AUX_321DA) {     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }   
  }
  
  if(statusBIT == LIS3DH_STATUS_AUX_3DA){
    if(value &= LIS3DH_STATUS_AUX_3DA){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }   
  }
  
  if(statusBIT == LIS3DH_STATUS_AUX_2DA){
    if(value &= LIS3DH_STATUS_AUX_2DA){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }  
  }
  
  if(statusBIT == LIS3DH_STATUS_AUX_1DA){
    if(value &= LIS3DH_STATUS_AUX_1DA){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }  
  }  
  return MEMS_ERROR;
}


@@ -926,19 +926,19 @@
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetODR(LIS3DH_ODR_t ov){
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG1, &value) )
    return MEMS_ERROR;
  
  value &= 0x0f;
  value |= ov<<LIS3DH_ODR_BIT;
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG1, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
status_t LIS3DH_SetODR(LIS3DH_ODR_t ov) {
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG1, &value) )
        return MEMS_ERROR;

    value &= 0x0f;
    value |= ov<<LIS3DH_ODR_BIT;

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG1, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -947,23 +947,23 @@
* Description    : Sets LIS3DH Output Temperature
* Input          : MEMS_ENABLE, MEMS_DISABLE
* Output         : None
* Note           : For Read Temperature by LIS3DH_OUT_AUX_3, LIS3DH_SetADCAux and LIS3DH_SetBDU 
* Note           : For Read Temperature by LIS3DH_OUT_AUX_3, LIS3DH_SetADCAux and LIS3DH_SetBDU
               functions must be ENABLE
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetTemperature(State_t state){
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_TEMP_CFG_REG, &value) )
    return MEMS_ERROR;
  
  value &= 0xBF;
  value |= state<<LIS3DH_TEMP_EN;
  
  if( !LIS3DH_WriteReg(LIS3DH_TEMP_CFG_REG, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
status_t LIS3DH_SetTemperature(State_t state) {
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_TEMP_CFG_REG, &value) )
        return MEMS_ERROR;

    value &= 0xBF;
    value |= state<<LIS3DH_TEMP_EN;

    if( !LIS3DH_WriteReg(LIS3DH_TEMP_CFG_REG, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -974,19 +974,19 @@
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetADCAux(State_t state){
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_TEMP_CFG_REG, &value) )
    return MEMS_ERROR;
  
  value &= 0x7F;
  value |= state<<LIS3DH_ADC_PD;
  
  if( !LIS3DH_WriteReg(LIS3DH_TEMP_CFG_REG, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
status_t LIS3DH_SetADCAux(State_t state) {
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_TEMP_CFG_REG, &value) )
        return MEMS_ERROR;

    value &= 0x7F;
    value |= state<<LIS3DH_ADC_PD;

    if( !LIS3DH_WriteReg(LIS3DH_TEMP_CFG_REG, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -998,34 +998,34 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetAuxRaw(LIS3DH_Aux123Raw_t* buff) {
  uint8_t valueL;
  uint8_t valueH;
  
  if( !LIS3DH_ReadReg(LIS3DH_OUT_1_L, &valueL) )
    return MEMS_ERROR;
  
  if( !LIS3DH_ReadReg(LIS3DH_OUT_1_H, &valueH) )
    return MEMS_ERROR;
  
  buff->AUX_1 = (uint16_t)( (valueH << 8) | valueL )/16;
  
  if( !LIS3DH_ReadReg(LIS3DH_OUT_2_L, &valueL) )
    return MEMS_ERROR;
  
  if( !LIS3DH_ReadReg(LIS3DH_OUT_2_H, &valueH) )
    return MEMS_ERROR;
  
  buff->AUX_2 = (uint16_t)( (valueH << 8) | valueL )/16;
  
  if( !LIS3DH_ReadReg(LIS3DH_OUT_3_L, &valueL) )
    return MEMS_ERROR;
  
  if( !LIS3DH_ReadReg(LIS3DH_OUT_3_H, &valueH) )
    return MEMS_ERROR;
  
  buff->AUX_3 = (uint16_t)( (valueH << 8) | valueL )/16;
  
  return MEMS_SUCCESS;  
    uint8_t valueL;
    uint8_t valueH;

    if( !LIS3DH_ReadReg(LIS3DH_OUT_1_L, &valueL) )
        return MEMS_ERROR;

    if( !LIS3DH_ReadReg(LIS3DH_OUT_1_H, &valueH) )
        return MEMS_ERROR;

    buff->AUX_1 = (uint16_t)( (valueH << 8) | valueL )/16;

    if( !LIS3DH_ReadReg(LIS3DH_OUT_2_L, &valueL) )
        return MEMS_ERROR;

    if( !LIS3DH_ReadReg(LIS3DH_OUT_2_H, &valueH) )
        return MEMS_ERROR;

    buff->AUX_2 = (uint16_t)( (valueH << 8) | valueL )/16;

    if( !LIS3DH_ReadReg(LIS3DH_OUT_3_L, &valueL) )
        return MEMS_ERROR;

    if( !LIS3DH_ReadReg(LIS3DH_OUT_3_H, &valueH) )
        return MEMS_ERROR;

    buff->AUX_3 = (uint16_t)( (valueH << 8) | valueL )/16;

    return MEMS_SUCCESS;
}


@@ -1037,18 +1037,18 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetTempRaw(int8_t* buff) {
  uint8_t valueL;
  uint8_t valueH;
  
  if( !LIS3DH_ReadReg(LIS3DH_OUT_3_L, &valueL) )
    return MEMS_ERROR;
  
  if( !LIS3DH_ReadReg(LIS3DH_OUT_3_H, &valueH) )
    return MEMS_ERROR;
  
  *buff = (int8_t)( valueH );
  
  return MEMS_SUCCESS;  
    uint8_t valueL;
    uint8_t valueH;

    if( !LIS3DH_ReadReg(LIS3DH_OUT_3_L, &valueL) )
        return MEMS_ERROR;

    if( !LIS3DH_ReadReg(LIS3DH_OUT_3_H, &valueH) )
        return MEMS_ERROR;

    *buff = (int8_t)( valueH );

    return MEMS_SUCCESS;
}


@@ -1060,51 +1060,51 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetMode(LIS3DH_Mode_t md) {
  uint8_t value;
  uint8_t value2;
  static   uint8_t ODR_old_value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG1, &value) )
    return MEMS_ERROR;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value2) )
    return MEMS_ERROR;
  
  if((value & 0xF0)==0) 
    value = value | (ODR_old_value & 0xF0); //if it comes from POWERDOWN  
  
  switch(md) {
    
  case LIS3DH_POWER_DOWN:
    ODR_old_value = value;
    value &= 0x0F;
    break;
    
  case LIS3DH_NORMAL:
    value &= 0xF7;
    value |= (MEMS_RESET<<LIS3DH_LPEN);
    value2 &= 0xF7;
    value2 |= (MEMS_SET<<LIS3DH_HR);   //set HighResolution_BIT
    break;
    
  case LIS3DH_LOW_POWER:		
    value &= 0xF7;
    value |=  (MEMS_SET<<LIS3DH_LPEN);
    value2 &= 0xF7;
    value2 |= (MEMS_RESET<<LIS3DH_HR); //reset HighResolution_BIT
    break;
    
  default:
    return MEMS_ERROR;
  }
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG1, value) )
    return MEMS_ERROR;
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value2) )
    return MEMS_ERROR;  
  
  return MEMS_SUCCESS;
    uint8_t value;
    uint8_t value2;
    static   uint8_t ODR_old_value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG1, &value) )
        return MEMS_ERROR;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value2) )
        return MEMS_ERROR;

    if((value & 0xF0)==0)
        value = value | (ODR_old_value & 0xF0); //if it comes from POWERDOWN

    switch(md) {

    case LIS3DH_POWER_DOWN:
        ODR_old_value = value;
        value &= 0x0F;
        break;

    case LIS3DH_NORMAL:
        value &= 0xF7;
        value |= (MEMS_RESET<<LIS3DH_LPEN);
        value2 &= 0xF7;
        value2 |= (MEMS_SET<<LIS3DH_HR);   //set HighResolution_BIT
        break;

    case LIS3DH_LOW_POWER:
        value &= 0xF7;
        value |=  (MEMS_SET<<LIS3DH_LPEN);
        value2 &= 0xF7;
        value2 |= (MEMS_RESET<<LIS3DH_HR); //reset HighResolution_BIT
        break;

    default:
        return MEMS_ERROR;
    }

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG1, value) )
        return MEMS_ERROR;

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value2) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1117,17 +1117,17 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetAxis(LIS3DH_Axis_t axis) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG1, &value) )
    return MEMS_ERROR;
  value &= 0xF8;
  value |= (0x07 & axis);
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG1, value) )
    return MEMS_ERROR;   
  
  return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG1, &value) )
        return MEMS_ERROR;
    value &= 0xF8;
    value |= (0x07 & axis);

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG1, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1139,18 +1139,18 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetFullScale(LIS3DH_Fullscale_t fs) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
    return MEMS_ERROR;
  
  value &= 0xCF;	
  value |= (fs<<LIS3DH_FS);
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
        return MEMS_ERROR;

    value &= 0xCF;
    value |= (fs<<LIS3DH_FS);

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1162,18 +1162,18 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetBDU(State_t bdu) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
    return MEMS_ERROR;
  
  value &= 0x7F;
  value |= (bdu<<LIS3DH_BDU);
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
        return MEMS_ERROR;

    value &= 0x7F;
    value |= (bdu<<LIS3DH_BDU);

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1185,18 +1185,18 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetBLE(LIS3DH_Endianess_t ble) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
    return MEMS_ERROR;
  
  value &= 0xBF;	
  value |= (ble<<LIS3DH_BLE);
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
        return MEMS_ERROR;

    value &= 0xBF;
    value |= (ble<<LIS3DH_BLE);

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1208,18 +1208,18 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetSelfTest(LIS3DH_SelfTest_t st) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
    return MEMS_ERROR;
  
  value &= 0xF9;
  value |= (st<<LIS3DH_ST);
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
        return MEMS_ERROR;

    value &= 0xF9;
    value |= (st<<LIS3DH_ST);

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1231,18 +1231,18 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_HPFClickEnable(State_t hpfe) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
    return MEMS_ERROR;
  
  value &= 0xFB;
  value |= (hpfe<<LIS3DH_HPCLICK);
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
        return MEMS_ERROR;

    value &= 0xFB;
    value |= (hpfe<<LIS3DH_HPCLICK);

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1254,18 +1254,18 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_HPFAOI1Enable(State_t hpfe) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
    return MEMS_ERROR;
  
  value &= 0xFE;
  value |= (hpfe<<LIS3DH_HPIS1);
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
        return MEMS_ERROR;

    value &= 0xFE;
    value |= (hpfe<<LIS3DH_HPIS1);

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1277,18 +1277,18 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_HPFAOI2Enable(State_t hpfe) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
    return MEMS_ERROR;
  
  value &= 0xFD;
  value |= (hpfe<<LIS3DH_HPIS2);
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
        return MEMS_ERROR;

    value &= 0xFD;
    value |= (hpfe<<LIS3DH_HPIS2);

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1301,18 +1301,18 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetHPFMode(LIS3DH_HPFMode_t hpm) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
    return MEMS_ERROR;
  
  value &= 0x3F;
  value |= (hpm<<LIS3DH_HPM);
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
        return MEMS_ERROR;

    value &= 0x3F;
    value |= (hpm<<LIS3DH_HPM);

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1324,22 +1324,22 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetHPFCutOFF(LIS3DH_HPFCutOffFreq_t hpf) {
  uint8_t value;
  
  if (hpf > 3)
    return MEMS_ERROR;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
    return MEMS_ERROR;
  
  value &= 0xCF;
  value |= (hpf<<LIS3DH_HPCF);
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
  
    uint8_t value;

    if (hpf > 3)
        return MEMS_ERROR;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
        return MEMS_ERROR;

    value &= 0xCF;
    value |= (hpf<<LIS3DH_HPCF);

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;

}


@@ -1351,106 +1351,106 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetFilterDataSel(State_t state) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
    return MEMS_ERROR;
  
  value &= 0xF7;
  value |= (state<<LIS3DH_FDS);
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
  
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
        return MEMS_ERROR;

    value &= 0xF7;
    value |= (state<<LIS3DH_FDS);

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;

}


/*******************************************************************************
* Function Name  : LIS3DH_SetInt1Pin
* Description    : Set Interrupt1 pin Function
* Input          :  LIS3DH_CLICK_ON_PIN_INT1_ENABLE/DISABLE    | LIS3DH_I1_INT1_ON_PIN_INT1_ENABLE/DISABLE |              
                    LIS3DH_I1_INT2_ON_PIN_INT1_ENABLE/DISABLE  | LIS3DH_I1_DRDY1_ON_INT1_ENABLE/DISABLE    |              
                    LIS3DH_I1_DRDY2_ON_INT1_ENABLE/DISABLE     | LIS3DH_WTM_ON_INT1_ENABLE/DISABLE         |           
                    LIS3DH_INT1_OVERRUN_ENABLE/DISABLE  
* example        : SetInt1Pin(LIS3DH_CLICK_ON_PIN_INT1_ENABLE | LIS3DH_I1_INT1_ON_PIN_INT1_ENABLE |              
* Input          :  LIS3DH_CLICK_ON_PIN_INT1_ENABLE/DISABLE    | LIS3DH_I1_INT1_ON_PIN_INT1_ENABLE/DISABLE |
                    LIS3DH_I1_INT2_ON_PIN_INT1_ENABLE/DISABLE  | LIS3DH_I1_DRDY1_ON_INT1_ENABLE/DISABLE    |
                    LIS3DH_I1_DRDY2_ON_INT1_ENABLE/DISABLE     | LIS3DH_WTM_ON_INT1_ENABLE/DISABLE         |
                    LIS3DH_INT1_OVERRUN_ENABLE/DISABLE
* example        : SetInt1Pin(LIS3DH_CLICK_ON_PIN_INT1_ENABLE | LIS3DH_I1_INT1_ON_PIN_INT1_ENABLE |
                    LIS3DH_I1_INT2_ON_PIN_INT1_DISABLE | LIS3DH_I1_DRDY1_ON_INT1_ENABLE | LIS3DH_I1_DRDY2_ON_INT1_ENABLE |
                    LIS3DH_WTM_ON_INT1_DISABLE | LIS3DH_INT1_OVERRUN_DISABLE   ) 
                    LIS3DH_WTM_ON_INT1_DISABLE | LIS3DH_INT1_OVERRUN_DISABLE   )
* Note           : To enable Interrupt signals on INT1 Pad (You MUST use all input variable in the argument, as example)
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetInt1Pin(LIS3DH_IntPinConf_t pinConf) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG3, &value) )
    return MEMS_ERROR;
  
  value &= 0x00;
  value |= pinConf;
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG3, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG3, &value) )
        return MEMS_ERROR;

    value &= 0x00;
    value |= pinConf;

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG3, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : LIS3DH_SetInt2Pin
* Description    : Set Interrupt2 pin Function
* Input          : LIS3DH_CLICK_ON_PIN_INT2_ENABLE/DISABLE   | LIS3DH_I2_INT1_ON_PIN_INT2_ENABLE/DISABLE |               
                   LIS3DH_I2_INT2_ON_PIN_INT2_ENABLE/DISABLE | LIS3DH_I2_BOOT_ON_INT2_ENABLE/DISABLE |                   
* Input          : LIS3DH_CLICK_ON_PIN_INT2_ENABLE/DISABLE   | LIS3DH_I2_INT1_ON_PIN_INT2_ENABLE/DISABLE |
                   LIS3DH_I2_INT2_ON_PIN_INT2_ENABLE/DISABLE | LIS3DH_I2_BOOT_ON_INT2_ENABLE/DISABLE |
                   LIS3DH_INT_ACTIVE_HIGH/LOW
* example        : LIS3DH_SetInt2Pin(LIS3DH_CLICK_ON_PIN_INT2_ENABLE/DISABLE | LIS3DH_I2_INT1_ON_PIN_INT2_ENABLE/DISABLE |               
                   LIS3DH_I2_INT2_ON_PIN_INT2_ENABLE/DISABLE | LIS3DH_I2_BOOT_ON_INT2_ENABLE/DISABLE |                   
* example        : LIS3DH_SetInt2Pin(LIS3DH_CLICK_ON_PIN_INT2_ENABLE/DISABLE | LIS3DH_I2_INT1_ON_PIN_INT2_ENABLE/DISABLE |
                   LIS3DH_I2_INT2_ON_PIN_INT2_ENABLE/DISABLE | LIS3DH_I2_BOOT_ON_INT2_ENABLE/DISABLE |
                   LIS3DH_INT_ACTIVE_HIGH/LOW)
* Note           : To enable Interrupt signals on INT2 Pad (You MUST use all input variable in the argument, as example)
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetInt2Pin(LIS3DH_IntPinConf_t pinConf) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG6, &value) )
    return MEMS_ERROR;
  
  value &= 0x00;
  value |= pinConf;
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG6, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
}                       
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG6, &value) )
        return MEMS_ERROR;

    value &= 0x00;
    value |= pinConf;

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG6, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : LIS3DH_SetClickCFG
* Description    : Set Click Interrupt config Function
* Input          : LIS3DH_ZD_ENABLE/DISABLE | LIS3DH_ZS_ENABLE/DISABLE  | LIS3DH_YD_ENABLE/DISABLE  | 
                   LIS3DH_YS_ENABLE/DISABLE | LIS3DH_XD_ENABLE/DISABLE  | LIS3DH_XS_ENABLE/DISABLE 
* example        : LIS3DH_SetClickCFG( LIS3DH_ZD_ENABLE | LIS3DH_ZS_DISABLE | LIS3DH_YD_ENABLE | 
* Input          : LIS3DH_ZD_ENABLE/DISABLE | LIS3DH_ZS_ENABLE/DISABLE  | LIS3DH_YD_ENABLE/DISABLE  |
                   LIS3DH_YS_ENABLE/DISABLE | LIS3DH_XD_ENABLE/DISABLE  | LIS3DH_XS_ENABLE/DISABLE
* example        : LIS3DH_SetClickCFG( LIS3DH_ZD_ENABLE | LIS3DH_ZS_DISABLE | LIS3DH_YD_ENABLE |
                               LIS3DH_YS_DISABLE | LIS3DH_XD_ENABLE | LIS3DH_XS_ENABLE)
* Note           : You MUST use all input variable in the argument, as example
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetClickCFG(uint8_t status) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CLICK_CFG, &value) )
    return MEMS_ERROR;
  
  value &= 0xC0;
  value |= status;
  
  if( !LIS3DH_WriteReg(LIS3DH_CLICK_CFG, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
}  
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CLICK_CFG, &value) )
        return MEMS_ERROR;

    value &= 0xC0;
    value |= status;

    if( !LIS3DH_WriteReg(LIS3DH_CLICK_CFG, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


/*******************************************************************************
@@ -1461,15 +1461,15 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetClickTHS(uint8_t ths) {
  
  if(ths>127)     
    return MEMS_ERROR;
  
  if( !LIS3DH_WriteReg(LIS3DH_CLICK_THS, ths) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
} 

    if(ths>127)
        return MEMS_ERROR;

    if( !LIS3DH_WriteReg(LIS3DH_CLICK_THS, ths) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


/*******************************************************************************
@@ -1480,15 +1480,15 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetClickLIMIT(uint8_t t_limit) {
  
  if(t_limit>127)     
    return MEMS_ERROR;
  
  if( !LIS3DH_WriteReg(LIS3DH_TIME_LIMIT, t_limit) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
} 

    if(t_limit>127)
        return MEMS_ERROR;

    if( !LIS3DH_WriteReg(LIS3DH_TIME_LIMIT, t_limit) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


/*******************************************************************************
@@ -1499,12 +1499,12 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetClickLATENCY(uint8_t t_latency) {
  
  if( !LIS3DH_WriteReg(LIS3DH_TIME_LATENCY, t_latency) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
} 

    if( !LIS3DH_WriteReg(LIS3DH_TIME_LATENCY, t_latency) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


/*******************************************************************************
@@ -1515,11 +1515,11 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetClickWINDOW(uint8_t t_window) {
  
  if( !LIS3DH_WriteReg(LIS3DH_TIME_WINDOW, t_window) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;

    if( !LIS3DH_WriteReg(LIS3DH_TIME_WINDOW, t_window) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1531,81 +1531,81 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetClickResponse(uint8_t* res) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CLICK_SRC, &value) ) 
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CLICK_SRC, &value) )
        return MEMS_ERROR;

    value &= 0x7F;

    if((value & LIS3DH_IA)==0) {
        *res = LIS3DH_NO_CLICK;
        return MEMS_SUCCESS;
    }
    else {
        if (value & LIS3DH_DCLICK) {
            if (value & LIS3DH_CLICK_SIGN) {
                if (value & LIS3DH_CLICK_Z) {
                    *res = LIS3DH_DCLICK_Z_N;
                    return MEMS_SUCCESS;
                }
                if (value & LIS3DH_CLICK_Y) {
                    *res = LIS3DH_DCLICK_Y_N;
                    return MEMS_SUCCESS;
                }
                if (value & LIS3DH_CLICK_X) {
                    *res = LIS3DH_DCLICK_X_N;
                    return MEMS_SUCCESS;
                }
            }
            else {
                if (value & LIS3DH_CLICK_Z) {
                    *res = LIS3DH_DCLICK_Z_P;
                    return MEMS_SUCCESS;
                }
                if (value & LIS3DH_CLICK_Y) {
                    *res = LIS3DH_DCLICK_Y_P;
                    return MEMS_SUCCESS;
                }
                if (value & LIS3DH_CLICK_X) {
                    *res = LIS3DH_DCLICK_X_P;
                    return MEMS_SUCCESS;
                }
            }
        }
        else {
            if (value & LIS3DH_CLICK_SIGN) {
                if (value & LIS3DH_CLICK_Z) {
                    *res = LIS3DH_SCLICK_Z_N;
                    return MEMS_SUCCESS;
                }
                if (value & LIS3DH_CLICK_Y) {
                    *res = LIS3DH_SCLICK_Y_N;
                    return MEMS_SUCCESS;
                }
                if (value & LIS3DH_CLICK_X) {
                    *res = LIS3DH_SCLICK_X_N;
                    return MEMS_SUCCESS;
                }
            }
            else {
                if (value & LIS3DH_CLICK_Z) {
                    *res = LIS3DH_SCLICK_Z_P;
                    return MEMS_SUCCESS;
                }
                if (value & LIS3DH_CLICK_Y) {
                    *res = LIS3DH_SCLICK_Y_P;
                    return MEMS_SUCCESS;
                }
                if (value & LIS3DH_CLICK_X) {
                    *res = LIS3DH_SCLICK_X_P;
                    return MEMS_SUCCESS;
                }
            }
        }
    }
    return MEMS_ERROR;
  
  value &= 0x7F;
  
  if((value & LIS3DH_IA)==0) {        
    *res = LIS3DH_NO_CLICK;     
    return MEMS_SUCCESS;
  }
  else {
    if (value & LIS3DH_DCLICK){
      if (value & LIS3DH_CLICK_SIGN){
        if (value & LIS3DH_CLICK_Z) {
          *res = LIS3DH_DCLICK_Z_N;   
          return MEMS_SUCCESS;
        }
        if (value & LIS3DH_CLICK_Y) {
          *res = LIS3DH_DCLICK_Y_N;   
          return MEMS_SUCCESS;
        }
        if (value & LIS3DH_CLICK_X) {
          *res = LIS3DH_DCLICK_X_N;   
          return MEMS_SUCCESS;
        }
      }
      else{
        if (value & LIS3DH_CLICK_Z) {
          *res = LIS3DH_DCLICK_Z_P;   
          return MEMS_SUCCESS;
        }
        if (value & LIS3DH_CLICK_Y) {
          *res = LIS3DH_DCLICK_Y_P;   
          return MEMS_SUCCESS;
        }
        if (value & LIS3DH_CLICK_X) {
          *res = LIS3DH_DCLICK_X_P;   
          return MEMS_SUCCESS;
        }
      }       
    }
    else{
      if (value & LIS3DH_CLICK_SIGN){
        if (value & LIS3DH_CLICK_Z) {
          *res = LIS3DH_SCLICK_Z_N;   
          return MEMS_SUCCESS;
        }
        if (value & LIS3DH_CLICK_Y) {
          *res = LIS3DH_SCLICK_Y_N;   
          return MEMS_SUCCESS;
        }
        if (value & LIS3DH_CLICK_X) {
          *res = LIS3DH_SCLICK_X_N;   
          return MEMS_SUCCESS;
        }
      }
      else{
        if (value & LIS3DH_CLICK_Z) {
          *res = LIS3DH_SCLICK_Z_P;   
          return MEMS_SUCCESS;
        }
        if (value & LIS3DH_CLICK_Y) {
          *res = LIS3DH_SCLICK_Y_P;   
          return MEMS_SUCCESS;
        }
        if (value & LIS3DH_CLICK_X) {
          *res = LIS3DH_SCLICK_X_P;   
          return MEMS_SUCCESS;
        }
      }
    }
  }
  return MEMS_ERROR;
} 
}


/*******************************************************************************
@@ -1616,18 +1616,18 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_Int1LatchEnable(State_t latch) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
    return MEMS_ERROR;
  
  value &= 0xF7;
  value |= latch<<LIS3DH_LIR_INT1;
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
        return MEMS_ERROR;

    value &= 0xF7;
    value |= latch<<LIS3DH_LIR_INT1;

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1639,12 +1639,12 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_ResetInt1Latch(void) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, &value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, &value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1657,45 +1657,45 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetIntConfiguration(LIS3DH_Int1Conf_t ic) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_INT1_CFG, &value) )
    return MEMS_ERROR;
  
  value &= 0x40; 
  value |= ic;
  
  if( !LIS3DH_WriteReg(LIS3DH_INT1_CFG, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
} 
    uint8_t value;

     
    if( !LIS3DH_ReadReg(LIS3DH_INT1_CFG, &value) )
        return MEMS_ERROR;

    value &= 0x40;
    value |= ic;

    if( !LIS3DH_WriteReg(LIS3DH_INT1_CFG, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : LIS3DH_SetIntMode
* Description    : Interrupt 1 Configuration mode (OR, 6D Movement, AND, 6D Position)
* Input          : LIS3DH_INT_MODE_OR, LIS3DH_INT_MODE_6D_MOVEMENT, LIS3DH_INT_MODE_AND, 
* Input          : LIS3DH_INT_MODE_OR, LIS3DH_INT_MODE_6D_MOVEMENT, LIS3DH_INT_MODE_AND,
               LIS3DH_INT_MODE_6D_POSITION
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetIntMode(LIS3DH_Int1Mode_t int_mode) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_INT1_CFG, &value) )
    return MEMS_ERROR;
  
  value &= 0x3F; 
  value |= (int_mode<<LIS3DH_INT_6D);
  
  if( !LIS3DH_WriteReg(LIS3DH_INT1_CFG, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_INT1_CFG, &value) )
        return MEMS_ERROR;

    value &= 0x3F;
    value |= (int_mode<<LIS3DH_INT_6D);

    if( !LIS3DH_WriteReg(LIS3DH_INT1_CFG, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}

    

/*******************************************************************************
* Function Name  : LIS3DH_SetInt6D4DConfiguration
* Description    : 6D, 4D Interrupt Configuration
@@ -1704,41 +1704,41 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetInt6D4DConfiguration(LIS3DH_INT_6D_4D_t ic) {
  uint8_t value;
  uint8_t value2;
  
  if( !LIS3DH_ReadReg(LIS3DH_INT1_CFG, &value) )
    return MEMS_ERROR;
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value2) )
    return MEMS_ERROR;
  
  if(ic == LIS3DH_INT1_6D_ENABLE){
    value &= 0xBF; 
    value |= (MEMS_ENABLE<<LIS3DH_INT_6D);
    value2 &= 0xFB; 
    value2 |= (MEMS_DISABLE<<LIS3DH_D4D_INT1);
  }
  
  if(ic == LIS3DH_INT1_4D_ENABLE){
    value &= 0xBF; 
    value |= (MEMS_ENABLE<<LIS3DH_INT_6D);
    value2 &= 0xFB; 
    value2 |= (MEMS_ENABLE<<LIS3DH_D4D_INT1);
  }
  
  if(ic == LIS3DH_INT1_6D_4D_DISABLE){
    value &= 0xBF; 
    value |= (MEMS_DISABLE<<LIS3DH_INT_6D);
    value2 &= 0xFB; 
    value2 |= (MEMS_DISABLE<<LIS3DH_D4D_INT1);
  }
  
  if( !LIS3DH_WriteReg(LIS3DH_INT1_CFG, value) )
    return MEMS_ERROR;
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value2) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;
    uint8_t value2;

    if( !LIS3DH_ReadReg(LIS3DH_INT1_CFG, &value) )
        return MEMS_ERROR;
    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value2) )
        return MEMS_ERROR;

    if(ic == LIS3DH_INT1_6D_ENABLE) {
        value &= 0xBF;
        value |= (MEMS_ENABLE<<LIS3DH_INT_6D);
        value2 &= 0xFB;
        value2 |= (MEMS_DISABLE<<LIS3DH_D4D_INT1);
    }

    if(ic == LIS3DH_INT1_4D_ENABLE) {
        value &= 0xBF;
        value |= (MEMS_ENABLE<<LIS3DH_INT_6D);
        value2 &= 0xFB;
        value2 |= (MEMS_ENABLE<<LIS3DH_D4D_INT1);
    }

    if(ic == LIS3DH_INT1_6D_4D_DISABLE) {
        value &= 0xBF;
        value |= (MEMS_DISABLE<<LIS3DH_INT_6D);
        value2 &= 0xFB;
        value2 |= (MEMS_DISABLE<<LIS3DH_D4D_INT1);
    }

    if( !LIS3DH_WriteReg(LIS3DH_INT1_CFG, value) )
        return MEMS_ERROR;
    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value2) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1749,36 +1749,36 @@
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_Get6DPosition(uint8_t* val){
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, &value) )
    return MEMS_ERROR;
  
  value &= 0x7F;
  
  switch (value){
  case LIS3DH_UP_SX:   
    *val = LIS3DH_UP_SX;    
    break;
  case LIS3DH_UP_DX:   
    *val = LIS3DH_UP_DX;    
    break;
  case LIS3DH_DW_SX:   
    *val = LIS3DH_DW_SX;    
    break;
  case LIS3DH_DW_DX:   
    *val = LIS3DH_DW_DX;    
    break;
  case LIS3DH_TOP:     
    *val = LIS3DH_TOP;      
    break;
  case LIS3DH_BOTTOM:  
    *val = LIS3DH_BOTTOM;   
    break;
  }
  
  return MEMS_SUCCESS;  
status_t LIS3DH_Get6DPosition(uint8_t* val) {
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, &value) )
        return MEMS_ERROR;

    value &= 0x7F;

    switch (value) {
    case LIS3DH_UP_SX:
        *val = LIS3DH_UP_SX;
        break;
    case LIS3DH_UP_DX:
        *val = LIS3DH_UP_DX;
        break;
    case LIS3DH_DW_SX:
        *val = LIS3DH_DW_SX;
        break;
    case LIS3DH_DW_DX:
        *val = LIS3DH_DW_DX;
        break;
    case LIS3DH_TOP:
        *val = LIS3DH_TOP;
        break;
    case LIS3DH_BOTTOM:
        *val = LIS3DH_BOTTOM;
        break;
    }

    return MEMS_SUCCESS;
}


@@ -1790,13 +1790,13 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetInt1Threshold(uint8_t ths) {
  if (ths > 127)
    return MEMS_ERROR;
  
  if( !LIS3DH_WriteReg(LIS3DH_INT1_THS, ths) )
    return MEMS_ERROR;    
  
  return MEMS_SUCCESS;
    if (ths > 127)
        return MEMS_ERROR;

    if( !LIS3DH_WriteReg(LIS3DH_INT1_THS, ths) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1808,123 +1808,123 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetInt1Duration(LIS3DH_Int1Conf_t id) {
  
  if (id > 127)
    return MEMS_ERROR;
  
  if( !LIS3DH_WriteReg(LIS3DH_INT1_DURATION, id) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;

    if (id > 127)
        return MEMS_ERROR;

    if( !LIS3DH_WriteReg(LIS3DH_INT1_DURATION, id) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : LIS3DH_FIFOModeEnable
* Description    : Sets Fifo Modality
* Input          : LIS3DH_FIFO_DISABLE, LIS3DH_FIFO_BYPASS_MODE, LIS3DH_FIFO_MODE, 
* Input          : LIS3DH_FIFO_DISABLE, LIS3DH_FIFO_BYPASS_MODE, LIS3DH_FIFO_MODE,
               LIS3DH_FIFO_STREAM_MODE, LIS3DH_FIFO_TRIGGER_MODE
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_FIFOModeEnable(LIS3DH_FifoMode_t fm) {
  uint8_t value;  
  
  if(fm == LIS3DH_FIFO_DISABLE) { 
    if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
      return MEMS_ERROR;
    
    value &= 0x1F;
    value |= (LIS3DH_FIFO_BYPASS_MODE<<LIS3DH_FM);                     
    
    if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )           //fifo mode bypass
      return MEMS_ERROR;   
    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
      return MEMS_ERROR;
    
    value &= 0xBF;    
    
    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) )               //fifo disable
      return MEMS_ERROR;   
  }
  
  if(fm == LIS3DH_FIFO_BYPASS_MODE)   {  
    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
      return MEMS_ERROR;
    
    value &= 0xBF;
    value |= MEMS_SET<<LIS3DH_FIFO_EN;
    
    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) )               //fifo enable
      return MEMS_ERROR;  
    if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
      return MEMS_ERROR;
    
    value &= 0x1f;
    value |= (fm<<LIS3DH_FM);                     //fifo mode configuration
    
    if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
      return MEMS_ERROR;
  }
  
  if(fm == LIS3DH_FIFO_MODE)   {
    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
      return MEMS_ERROR;
    
    value &= 0xBF;
    value |= MEMS_SET<<LIS3DH_FIFO_EN;
    
    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) )               //fifo enable
      return MEMS_ERROR;  
    if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
      return MEMS_ERROR;
    
    value &= 0x1f;
    value |= (fm<<LIS3DH_FM);                      //fifo mode configuration
    
    if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
      return MEMS_ERROR;
  }
  
  if(fm == LIS3DH_FIFO_STREAM_MODE)   {  
    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
      return MEMS_ERROR;
    
    value &= 0xBF;
    value |= MEMS_SET<<LIS3DH_FIFO_EN;
    
    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) )               //fifo enable
      return MEMS_ERROR;   
    if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
      return MEMS_ERROR;
    
    value &= 0x1f;
    value |= (fm<<LIS3DH_FM);                      //fifo mode configuration
    
    if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
      return MEMS_ERROR;
  }
  
  if(fm == LIS3DH_FIFO_TRIGGER_MODE)   {  
    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
      return MEMS_ERROR;
    
    value &= 0xBF;
    value |= MEMS_SET<<LIS3DH_FIFO_EN;
    
    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) )               //fifo enable
      return MEMS_ERROR;    
    if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
      return MEMS_ERROR;
    
    value &= 0x1f;
    value |= (fm<<LIS3DH_FM);                      //fifo mode configuration
    
    if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
      return MEMS_ERROR;
  }
  
  return MEMS_SUCCESS;
    uint8_t value;

    if(fm == LIS3DH_FIFO_DISABLE) {
        if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
            return MEMS_ERROR;

        value &= 0x1F;
        value |= (LIS3DH_FIFO_BYPASS_MODE<<LIS3DH_FM);

        if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )           //fifo mode bypass
            return MEMS_ERROR;
        if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
            return MEMS_ERROR;

        value &= 0xBF;

        if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) )               //fifo disable
            return MEMS_ERROR;
    }

    if(fm == LIS3DH_FIFO_BYPASS_MODE)   {
        if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
            return MEMS_ERROR;

        value &= 0xBF;
        value |= MEMS_SET<<LIS3DH_FIFO_EN;

        if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) )               //fifo enable
            return MEMS_ERROR;
        if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
            return MEMS_ERROR;

        value &= 0x1f;
        value |= (fm<<LIS3DH_FM);                     //fifo mode configuration

        if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
            return MEMS_ERROR;
    }

    if(fm == LIS3DH_FIFO_MODE)   {
        if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
            return MEMS_ERROR;

        value &= 0xBF;
        value |= MEMS_SET<<LIS3DH_FIFO_EN;

        if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) )               //fifo enable
            return MEMS_ERROR;
        if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
            return MEMS_ERROR;

        value &= 0x1f;
        value |= (fm<<LIS3DH_FM);                      //fifo mode configuration

        if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
            return MEMS_ERROR;
    }

    if(fm == LIS3DH_FIFO_STREAM_MODE)   {
        if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
            return MEMS_ERROR;

        value &= 0xBF;
        value |= MEMS_SET<<LIS3DH_FIFO_EN;

        if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) )               //fifo enable
            return MEMS_ERROR;
        if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
            return MEMS_ERROR;

        value &= 0x1f;
        value |= (fm<<LIS3DH_FM);                      //fifo mode configuration

        if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
            return MEMS_ERROR;
    }

    if(fm == LIS3DH_FIFO_TRIGGER_MODE)   {
        if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
            return MEMS_ERROR;

        value &= 0xBF;
        value |= MEMS_SET<<LIS3DH_FIFO_EN;

        if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) )               //fifo enable
            return MEMS_ERROR;
        if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
            return MEMS_ERROR;

        value &= 0x1f;
        value |= (fm<<LIS3DH_FM);                      //fifo mode configuration

        if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
            return MEMS_ERROR;
    }

    return MEMS_SUCCESS;
}


@@ -1936,18 +1936,18 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetTriggerInt(LIS3DH_TrigInt_t tr) {
  uint8_t value;  
  
  if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
    return MEMS_ERROR;
  
  value &= 0xDF;
  value |= (tr<<LIS3DH_TR); 
  
  if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
        return MEMS_ERROR;

    value &= 0xDF;
    value |= (tr<<LIS3DH_TR);

    if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1959,24 +1959,24 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetWaterMark(uint8_t wtm) {
  uint8_t value;
  
  if(wtm > 31)
    return MEMS_ERROR;  
  
  if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
    return MEMS_ERROR;
  
  value &= 0xE0;
  value |= wtm; 
  
  if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;

    if(wtm > 31)
        return MEMS_ERROR;

    if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
        return MEMS_ERROR;

    value &= 0xE0;
    value |= wtm;

    if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}

  

/*******************************************************************************
* Function Name  : LIS3DH_GetStatusReg
* Description    : Read the status register
@@ -1985,10 +1985,10 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetStatusReg(uint8_t* val) {
  if( !LIS3DH_ReadReg(LIS3DH_STATUS_REG, val) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;  
    if( !LIS3DH_ReadReg(LIS3DH_STATUS_REG, val) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -1996,94 +1996,94 @@
* Function Name  : LIS3DH_GetStatusBIT
* Description    : Read the status register BIT
* Input          : LIS3DH_STATUS_REG_ZYXOR, LIS3DH_STATUS_REG_ZOR, LIS3DH_STATUS_REG_YOR, LIS3DH_STATUS_REG_XOR,
                   LIS3DH_STATUS_REG_ZYXDA, LIS3DH_STATUS_REG_ZDA, LIS3DH_STATUS_REG_YDA, LIS3DH_STATUS_REG_XDA, 
                   LIS3DH_STATUS_REG_ZYXDA, LIS3DH_STATUS_REG_ZDA, LIS3DH_STATUS_REG_YDA, LIS3DH_STATUS_REG_XDA,
               LIS3DH_DATAREADY_BIT
               val: Byte to be filled with the status bit	
               val: Byte to be filled with the status bit
* Output         : status register BIT
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetStatusBit(uint8_t statusBIT, uint8_t* val) {
  uint8_t value;  
  
  if( !LIS3DH_ReadReg(LIS3DH_STATUS_REG, &value) )
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_STATUS_REG, &value) )
        return MEMS_ERROR;

    switch (statusBIT) {
    case LIS3DH_STATUS_REG_ZYXOR:
        if(value &= LIS3DH_STATUS_REG_ZYXOR) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    case LIS3DH_STATUS_REG_ZOR:
        if(value &= LIS3DH_STATUS_REG_ZOR) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    case LIS3DH_STATUS_REG_YOR:
        if(value &= LIS3DH_STATUS_REG_YOR) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    case LIS3DH_STATUS_REG_XOR:
        if(value &= LIS3DH_STATUS_REG_XOR) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    case LIS3DH_STATUS_REG_ZYXDA:
        if(value &= LIS3DH_STATUS_REG_ZYXDA) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    case LIS3DH_STATUS_REG_ZDA:
        if(value &= LIS3DH_STATUS_REG_ZDA) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    case LIS3DH_STATUS_REG_YDA:
        if(value &= LIS3DH_STATUS_REG_YDA) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    case LIS3DH_STATUS_REG_XDA:
        if(value &= LIS3DH_STATUS_REG_XDA) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }

    }
    return MEMS_ERROR;
  
  switch (statusBIT){
  case LIS3DH_STATUS_REG_ZYXOR:     
    if(value &= LIS3DH_STATUS_REG_ZYXOR){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }  
  case LIS3DH_STATUS_REG_ZOR:       
    if(value &= LIS3DH_STATUS_REG_ZOR){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }  
  case LIS3DH_STATUS_REG_YOR:       
    if(value &= LIS3DH_STATUS_REG_YOR){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }                                 
  case LIS3DH_STATUS_REG_XOR:       
    if(value &= LIS3DH_STATUS_REG_XOR){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }     
  case LIS3DH_STATUS_REG_ZYXDA:     
    if(value &= LIS3DH_STATUS_REG_ZYXDA){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }   
  case LIS3DH_STATUS_REG_ZDA:       
    if(value &= LIS3DH_STATUS_REG_ZDA){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }   
  case LIS3DH_STATUS_REG_YDA:       
    if(value &= LIS3DH_STATUS_REG_YDA){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }   
  case LIS3DH_STATUS_REG_XDA:       
    if(value &= LIS3DH_STATUS_REG_XDA){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }                                  
    
  }
  return MEMS_ERROR;
}


@@ -2095,35 +2095,35 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetAccAxesRaw(AxesRaw_t* buff) {
  int16_t value;
  uint8_t *valueL = (uint8_t *)(&value);
  uint8_t *valueH = ((uint8_t *)(&value)+1);
  
  if( !LIS3DH_ReadReg(LIS3DH_OUT_X_L, valueL) )
    return MEMS_ERROR;
  
  if( !LIS3DH_ReadReg(LIS3DH_OUT_X_H, valueH) )
    return MEMS_ERROR;
  
  buff->AXIS_X = value;
  
  if( !LIS3DH_ReadReg(LIS3DH_OUT_Y_L, valueL) )
    return MEMS_ERROR;
  
  if( !LIS3DH_ReadReg(LIS3DH_OUT_Y_H, valueH) )
    return MEMS_ERROR;
  
  buff->AXIS_Y = value;
  
  if( !LIS3DH_ReadReg(LIS3DH_OUT_Z_L, valueL) )
    return MEMS_ERROR;
  
  if( !LIS3DH_ReadReg(LIS3DH_OUT_Z_H, valueH) )
    return MEMS_ERROR;
  
  buff->AXIS_Z = value;
  
  return MEMS_SUCCESS; 
    int16_t value;
    uint8_t *valueL = (uint8_t *)(&value);
    uint8_t *valueH = ((uint8_t *)(&value)+1);

    if( !LIS3DH_ReadReg(LIS3DH_OUT_X_L, valueL) )
        return MEMS_ERROR;

    if( !LIS3DH_ReadReg(LIS3DH_OUT_X_H, valueH) )
        return MEMS_ERROR;

    buff->AXIS_X = value;

    if( !LIS3DH_ReadReg(LIS3DH_OUT_Y_L, valueL) )
        return MEMS_ERROR;

    if( !LIS3DH_ReadReg(LIS3DH_OUT_Y_H, valueH) )
        return MEMS_ERROR;

    buff->AXIS_Y = value;

    if( !LIS3DH_ReadReg(LIS3DH_OUT_Z_L, valueL) )
        return MEMS_ERROR;

    if( !LIS3DH_ReadReg(LIS3DH_OUT_Z_H, valueH) )
        return MEMS_ERROR;

    buff->AXIS_Z = value;

    return MEMS_SUCCESS;
}


@@ -2135,11 +2135,11 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetInt1Src(uint8_t* val) {
  
  if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, val) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;

    if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, val) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -2152,87 +2152,87 @@
* Return         : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetInt1SrcBit(uint8_t statusBIT, uint8_t* val) {
  uint8_t value;  
   
  if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, &value) )
      return MEMS_ERROR;
   
  if(statusBIT == LIS3DH_INT1_SRC_IA){
    if(value &= LIS3DH_INT1_SRC_IA){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, &value) )
        return MEMS_ERROR;

    if(statusBIT == LIS3DH_INT1_SRC_IA) {
        if(value &= LIS3DH_INT1_SRC_IA) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }  
  }
  
  if(statusBIT == LIS3DH_INT1_SRC_ZH){
    if(value &= LIS3DH_INT1_SRC_ZH){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;

    if(statusBIT == LIS3DH_INT1_SRC_ZH) {
        if(value &= LIS3DH_INT1_SRC_ZH) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }  
  }
  
  if(statusBIT == LIS3DH_INT1_SRC_ZL){
    if(value &= LIS3DH_INT1_SRC_ZL){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;

    if(statusBIT == LIS3DH_INT1_SRC_ZL) {
        if(value &= LIS3DH_INT1_SRC_ZL) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }  
  }
  
  if(statusBIT == LIS3DH_INT1_SRC_YH){
    if(value &= LIS3DH_INT1_SRC_YH){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;

    if(statusBIT == LIS3DH_INT1_SRC_YH) {
        if(value &= LIS3DH_INT1_SRC_YH) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }  
  }
  
  if(statusBIT == LIS3DH_INT1_SRC_YL){
    if(value &= LIS3DH_INT1_SRC_YL){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;

    if(statusBIT == LIS3DH_INT1_SRC_YL) {
        if(value &= LIS3DH_INT1_SRC_YL) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }  
  }
  if(statusBIT == LIS3DH_INT1_SRC_XH){
    if(value &= LIS3DH_INT1_SRC_XH){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    if(statusBIT == LIS3DH_INT1_SRC_XH) {
        if(value &= LIS3DH_INT1_SRC_XH) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }  
  }
  
  if(statusBIT == LIS3DH_INT1_SRC_XL){
    if(value &= LIS3DH_INT1_SRC_XL){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;

    if(statusBIT == LIS3DH_INT1_SRC_XL) {
        if(value &= LIS3DH_INT1_SRC_XL) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }  
  }
  return MEMS_ERROR;
    return MEMS_ERROR;
}


@@ -2244,11 +2244,11 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetFifoSourceReg(uint8_t* val) {
  
  if( !LIS3DH_ReadReg(LIS3DH_FIFO_SRC_REG, val) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;

    if( !LIS3DH_ReadReg(LIS3DH_FIFO_SRC_REG, val) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}


@@ -2260,45 +2260,45 @@
* Output         : None
* Return         : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetFifoSourceBit(uint8_t statusBIT,  uint8_t* val){
  uint8_t value;  
  
  if( !LIS3DH_ReadReg(LIS3DH_FIFO_SRC_REG, &value) )
status_t LIS3DH_GetFifoSourceBit(uint8_t statusBIT,  uint8_t* val) {
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_FIFO_SRC_REG, &value) )
        return MEMS_ERROR;


    if(statusBIT == LIS3DH_FIFO_SRC_WTM) {
        if(value &= LIS3DH_FIFO_SRC_WTM) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }

    if(statusBIT == LIS3DH_FIFO_SRC_OVRUN) {
        if(value &= LIS3DH_FIFO_SRC_OVRUN) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }
    if(statusBIT == LIS3DH_FIFO_SRC_EMPTY) {
        if(value &= statusBIT == LIS3DH_FIFO_SRC_EMPTY) {
            *val = MEMS_SET;
            return MEMS_SUCCESS;
        }
        else {
            *val = MEMS_RESET;
            return MEMS_SUCCESS;
        }
    }
    return MEMS_ERROR;
  
  
  if(statusBIT == LIS3DH_FIFO_SRC_WTM){
    if(value &= LIS3DH_FIFO_SRC_WTM){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }  
  }
  
  if(statusBIT == LIS3DH_FIFO_SRC_OVRUN){
    if(value &= LIS3DH_FIFO_SRC_OVRUN){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }  
  }
  if(statusBIT == LIS3DH_FIFO_SRC_EMPTY){
    if(value &= statusBIT == LIS3DH_FIFO_SRC_EMPTY){     
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{  
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }  
  }
  return MEMS_ERROR;
}


@@ -2309,20 +2309,20 @@
* Output         : None
* Return         : Status [value of FSS]
*******************************************************************************/
status_t LIS3DH_GetFifoSourceFSS(uint8_t* val){
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_FIFO_SRC_REG, &value) )
    return MEMS_ERROR;
  
  value &= 0x1F;
  
  *val = value;
  
  return MEMS_SUCCESS;
status_t LIS3DH_GetFifoSourceFSS(uint8_t* val) {
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_FIFO_SRC_REG, &value) )
        return MEMS_ERROR;

    value &= 0x1F;

    *val = value;

    return MEMS_SUCCESS;
}

      

/*******************************************************************************
* Function Name  : LIS3DH_SetSPIInterface
* Description    : Set SPI mode: 3 Wire Interface OR 4 Wire Interface
@@ -2331,18 +2331,18 @@
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetSPIInterface(LIS3DH_SPIMode_t spi) {
  uint8_t value;
  
  if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
    return MEMS_ERROR;
  
  value &= 0xFE;
  value |= spi<<LIS3DH_SIM;
  
  if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
    return MEMS_ERROR;
  
  return MEMS_SUCCESS;
    uint8_t value;

    if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
        return MEMS_ERROR;

    value &= 0xFE;
    value |= spi<<LIS3DH_SIM;

    if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
        return MEMS_ERROR;

    return MEMS_SUCCESS;
}
/******************* (C) COPYRIGHT 2012 STMicroelectronics *****END OF FILE****/