/******************** (C) COPYRIGHT 2012 STMicroelectronics ********************
|
* File Name : LIS3DH_driver.c
|
* Author : MSH Application Team
|
* Author : Fabio Tota
|
* Version : $Revision:$
|
* Date : $Date:$
|
* Description : LIS3DH driver file
|
*
|
* HISTORY:
|
* Date | Modification | Author
|
* 24/06/2011 | Initial Revision | Fabio Tota
|
* 11/06/2012 | Support for multiple drivers in the same program | Abhishek Anand
|
|
********************************************************************************
|
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
|
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
|
* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
|
* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
|
* CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
|
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
|
*
|
* THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS.
|
*
|
*******************************************************************************/
|
|
/* Includes ------------------------------------------------------------------*/
|
|
#include "lis3dh_driver.h"
|
#include "stdlib.h"
|
#include "math.h"
|
#include "stdint.h"
|
#include "mk_io.h"
|
#include "mk_gpio.h"
|
#include "global_param.h"
|
/* Private typedef -----------------------------------------------------------*/
|
/* Private define ------------------------------------------------------------*/
|
/* Private macro -------------------------------------------------------------*/
|
/* Private variables ---------------------------------------------------------*/
|
/* Private function prototypes -----------------------------------------------*/
|
|
//int main(void)
|
//{
|
// delay_init(); //ÑÓʱº¯Êý³õʼ»¯
|
// uart_init(115200); //´®¿Ú³õʼ»¯Îª115200
|
// IIC2_Init();
|
// delay_ms(100);
|
// while(1)
|
// {
|
// LIS3DH_Data_Init();
|
// delay_ms(1000);
|
// }
|
//
|
//}
|
|
|
|
|
#define ARM_BIT_8 0
|
|
#if ARM_BIT_8
|
//ÈçÏÂÊý¾ÝÀàÐÍÊÇÔÚ8λ»úÉ϶¨ÒåµÄ£¬ÔÚÆäËüƽ̨£¨±ÈÈç32룩¿ÉÄÜ´æÔÚ²î±ð£¬ÐèÒª¸ù¾Ýʵ¼ÊÇé¿öÐÞ¸Ä ¡£
|
typedef unsigned char u8_m; /* ÎÞ·ûºÅ8λÕûÐͱäÁ¿*/
|
typedef signed char s8_m; /* ÓзûºÅ8λÕûÐͱäÁ¿*/
|
typedef unsigned int u16_m; /* ÎÞ·ûºÅ16λÕûÐͱäÁ¿*/
|
typedef signed int s16_m; /* ÓзûºÅ16λÕûÐͱäÁ¿*/
|
typedef unsigned long u32_m; /* ÎÞ·ûºÅ32λÕûÐͱäÁ¿*/
|
typedef signed long s32_m; /* ÓзûºÅ32λÕûÐͱäÁ¿*/
|
typedef float fp32_m; /* µ¥¾«¶È¸¡µãÊý£¨32볤¶È£©*/
|
typedef double fp64_m; /* Ë«¾«¶È¸¡µãÊý£¨64볤¶È£©*/
|
#else
|
//ÈçÏÂÊý¾ÝÀàÐÍÊÇÔÚ32λ»úÉ϶¨ÒåµÄ£¬ÔÚÆäËüƽ̨£¨±ÈÈç8룩¿ÉÄÜ´æÔÚ²î±ð£¬ÐèÒª¸ù¾Ýʵ¼ÊÇé¿öÐÞ¸Ä ¡£
|
typedef unsigned char u8_m; /* ÎÞ·ûºÅ8λÕûÐͱäÁ¿*/
|
typedef signed char s8_m; /* ÓзûºÅ8λÕûÐͱäÁ¿*/
|
typedef unsigned short u16_m; /* ÎÞ·ûºÅ16λÕûÐͱäÁ¿*/
|
typedef signed short s16_m; /* ÓзûºÅ16λÕûÐͱäÁ¿*/
|
typedef unsigned int u32_m; /* ÎÞ·ûºÅ32λÕûÐͱäÁ¿*/
|
typedef signed int s32_m; /* ÓзûºÅ32λÕûÐͱäÁ¿*/
|
typedef float fp32_m; /* µ¥¾«¶È¸¡µãÊý£¨32볤¶È£©*/
|
typedef double fp64_m; /* Ë«¾«¶È¸¡µãÊý£¨64볤¶È£©*/
|
#endif
|
|
/*******************************************************************************
|
Macro definitions - Register define for Gsensor
|
********************************************************************************/
|
#define REG_SPI_CONFIG 0x00
|
#define REG_CHIP_ID 0x01
|
#define REG_ACC_X_LSB 0x02
|
#define REG_ACC_X_MSB 0x03
|
#define REG_ACC_Y_LSB 0x04
|
#define REG_ACC_Y_MSB 0x05
|
#define REG_ACC_Z_LSB 0x06
|
#define REG_ACC_Z_MSB 0x07
|
#define REG_FIFO_STATUS 0x08
|
#define REG_MOTION_FLAG 0x09
|
#define REG_NEWDATA_FLAG 0x0A
|
#define REG_TAP_ACTIVE_STATUS 0x0B
|
#define REG_ORIENT_STATUS 0x0C
|
#define REG_STEPS_MSB 0x0D
|
#define REG_STEPS_LSB 0x0E
|
#define REG_RESOLUTION_RANGE 0x0F
|
#define REG_ODR_AXIS 0x10
|
#define REG_MODE_BW 0x11
|
#define REG_SWAP_POLARITY 0x12
|
#define REG_FIFO_CTRL 0x14
|
#define REG_INT_SET0 0x15
|
#define REG_INT_SET1 0x16
|
#define REG_INT_SET2 0x17
|
#define REG_INT_MAP1 0x19
|
#define REG_INT_MAP2 0x1a
|
#define REG_INT_MAP3 0x1b
|
#define REG_INT_CONFIG 0x20
|
#define REG_INT_LATCH 0x21
|
#define REG_FREEFALL_DUR 0x22
|
#define REG_FREEFALL_THS 0x23
|
#define REG_FREEFALL_HYST 0x24
|
#define REG_ACTIVE_DUR 0x27
|
#define REG_ACTIVE_THS 0x28
|
#define REG_TAP_DUR 0x2A
|
#define REG_TAP_THS 0x2B
|
#define REG_ORIENT_HYST 0x2C
|
#define REG_Z_BLOCK 0x2D
|
#define REG_RESET_STEP 0x2E
|
#define REG_STEP_CONGIF1 0x2F
|
#define REG_STEP_CONGIF2 0x30
|
#define REG_STEP_CONGIF3 0x31
|
#define REG_STEP_CONGIF4 0x32
|
#define REG_STEP_FILTER 0x33
|
#define REG_SM_THRESHOLD 0x34
|
|
#define DIFF_CALIBRATION 1
|
|
|
u8_m i2c_addr = 0x27;
|
|
s16_m offset_x=0, offset_y=0, offset_z=0;
|
|
u16_m f_step=0;
|
|
|
s8_m mir3da_register_read(u8_m ReadAddr, u8_m *data_m, u8_m Len)
|
{
|
|
mir3da_ReadOneByte(ReadAddr);
|
|
}
|
|
s8_m mir3da_register_write(u8_m ReadAddr, u8_m 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 |= data & mask;
|
res |= mir3da_register_write(ReadAddr, tmp_data);
|
|
return 0;
|
}
|
|
|
static 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();
|
|
|
}
|
}
|
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
|
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);
|
//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);
|
}
|
|
uint8_t lisid;
|
uint8_t lisidtemp;
|
|
void Accelerometer_Init()
|
{
|
|
// LIS3DH_GetWHO_AM_I(&lisidtemp);
|
// lisid=(uint16_t)lisidtemp;
|
|
// if(lisid == 0x33)
|
// {
|
// LIS3DH_Data_Init();
|
// }
|
// else
|
// {
|
// g_com_map[IMU_ENABLE]=0;
|
// }
|
lisid = mir3da_ReadOneByte(REG_CHIP_ID);
|
SL_SC7A22H_Check();
|
if(lisid == 0x13)
|
{
|
mir3da_init();
|
}
|
else
|
{
|
LIS3DH_GetWHO_AM_I(&lisidtemp);
|
lisid=(uint16_t)lisidtemp;
|
|
if(lisid == 0x33)
|
{
|
LIS3DH_Data_Init();
|
}
|
else
|
{
|
g_com_map[IMU_ENABLE]=0;
|
}
|
}
|
}
|
|
void mir3da_init()
|
{
|
u8_m data_m = 0;
|
int i;
|
int threshold = 0;
|
|
|
//softreset
|
mir3da_register_write(REG_SPI_CONFIG, 0x24);
|
delay_us(20000);
|
|
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);
|
|
//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);
|
|
}
|
|
|
void LIS3DH_Data_Init()
|
{
|
//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_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);
|
// lisid=(uint16_t)lisidtemp;
|
|
|
|
//get Acceleration Raw data
|
// response=LIS3DH_GetAccAxesRaw(&data);
|
//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),
|
// (int16_t)((float)lis2dhdata.AXIS_Z*4/65536*1000));
|
//
|
// }
|
|
}
|
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);
|
//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);
|
// lisid=(uint16_t)lisidtemp;
|
// printf("LIS3DH ID: %x \r\n",lisid);
|
//get Acceleration Raw data
|
// response=LIS3DH_GetAccAxesRaw(&data);
|
//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),
|
// (int16_t)((float)lis2dhdata.AXIS_Z*4/65536*1000));
|
//
|
// }
|
|
}
|
|
|
//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);
|
}
|
|
//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);
|
|
*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;
|
}
|
|
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);
|
|
*x = ((short)(tmp_data[1] << 8 | tmp_data[0])) >> 4 - offset_x;
|
*y = ((short)(tmp_data[3] << 8 | tmp_data[2])) >> 4 - offset_y;
|
*z = ((short)(tmp_data[5] << 8 | tmp_data[4])) >> 4 - offset_z;
|
}
|
|
//open active interrupt
|
void mir3da_set_active_interrupt_enable(int enable)
|
{
|
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_SET1,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);
|
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, 0x22);
|
}
|
}
|
|
void mir3da_reset_step_counter(void)
|
{
|
mir3da_register_mask_write(REG_RESET_STEP, 0x80, 0x80);
|
}
|
|
|
u16_m mir3da_get_step() //»ñµÃÔ˶¯²½Êý
|
{
|
u8_m tmp_data[2] = {0};
|
|
f_step = mir3da_ReadLenByte(REG_STEPS_MSB, 2);
|
|
return f_step;
|
|
}
|
|
//»ñÈ¡Êý¾Ý
|
|
float acc_g;
|
|
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);
|
// 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);
|
// 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;
|
|
/* 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;
|
}
|
|
void IIC2_SDA_OUT()
|
{
|
gpio_pin_set_dir(SDA_PIN , GPIO_DIR_OUT, 1);
|
}
|
void IIC2_SDA_IN()
|
{
|
gpio_pin_set_dir(SDA_PIN,GPIO_DIR_IN,1); //SDAÉèÖÃΪÊäÈëµÈ´ý½ÓÊն˵ÄÓ¦´ðÐźÅ
|
}
|
//²úÉúIICÆðʼÐźÅ
|
void IIC2_Start(void)
|
{
|
IIC2_SDA_OUT(); //sdaÏßÊä³ö
|
SDA_1;
|
// delay_us(10);
|
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;
|
// delay_us(10);
|
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);
|
|
}
|
|
//µÈ´ýÓ¦´ðÐźŵ½À´
|
//·µ»ØÖµ£º1£¬½ÓÊÕÓ¦´ðʧ°Ü
|
// 0£¬½ÓÊÕÓ¦´ð³É¹¦
|
uint8_t IIC2_Wait_Ack(void)
|
{
|
uint8_t ucErrTime=0;
|
IIC2_SDA_IN();
|
SDA_1;
|
delay_us(15);
|
SCL_1;
|
delay_us(15);
|
|
while(IIC2_READ_SDA)
|
{
|
ucErrTime++;
|
if(ucErrTime>250)
|
{
|
IIC2_Stop();
|
return 1;
|
}
|
}
|
SCL_0;//ʱÖÓÊä³ö0
|
return 0;
|
}
|
//²úÉúACKÓ¦´ð
|
void IIC2_Ack(void)
|
{
|
SCL_0;
|
IIC2_SDA_OUT();
|
SDA_0;
|
delay_us(10);
|
SCL_1;
|
delay_us(10);
|
SCL_0;
|
}
|
//²»²úÉúACKÓ¦´ð
|
void IIC2_NAck(void)
|
{
|
SCL_0;
|
IIC2_SDA_OUT();
|
SDA_1;
|
delay_us(10);
|
SCL_1;
|
delay_us(10);
|
SCL_0;
|
}
|
|
|
//IIC·¢ËÍÒ»¸ö×Ö½Ú,WRITE
|
//·µ»Ø´Ó»úÓÐÎÞÓ¦´ð
|
//1£¬ÓÐÓ¦´ð
|
//0£¬ÎÞÓ¦´ð
|
void IIC2_Send_Byte(uint8_t txd)
|
{
|
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);
|
}
|
}
|
|
//¶Á1¸ö×Ö½Ú£¬ack=1ʱ£¬·¢ËÍACK£¬ack=0£¬·¢ËÍnACK
|
uint8_t IIC2_Read_Byte(unsigned char ack)
|
{
|
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);
|
}
|
if (!ack)
|
IIC2_NAck();//·¢ËÍnACK
|
else
|
IIC2_Ack(); //·¢ËÍACK
|
return receive;
|
}
|
|
//ÔÚLIS3DHÀïÃæµÄÖ¸¶¨µØÖ·¿ªÊ¼¶ÁÒ»×Ö½ÚÊý¾Ý
|
//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;
|
}
|
//ÔÚLIS3DHÖ¸¶¨µØַдÈëÒ»¸öÊý¾Ý
|
//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);
|
|
}
|
//ÔÚAT24CXXÀïÃæµÄÖ¸¶¨µØÖ·¿ªÊ¼Ð´È볤¶ÈΪLenµÄÊý¾Ý
|
//¸Ãº¯ÊýÓÃÓÚдÈë16bit»òÕß32bitµÄÊý¾Ý.
|
//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);
|
}
|
}
|
|
//ÔÚAT24CXXÀïÃæµÄÖ¸¶¨µØÖ·¿ªÊ¼¶Á³ö³¤¶ÈΪLenµÄÊý¾Ý
|
//¸Ãº¯ÊýÓÃÓÚ¶Á³ö16bit»òÕß32bitµÄÊý¾Ý.
|
//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;
|
}
|
void SC7A22H_ReadLenByte(uint16_t ReadAddr, uint8_t Len, uint8_t *buf)
|
{
|
for(uint8_t t = 0; t < Len; t++)
|
{
|
buf[t] = LIS3DH_ReadOneByte(ReadAddr + t);
|
}
|
}
|
//ÔÚmir3daÀïÃæµÄÖ¸¶¨µØÖ·¿ªÊ¼¶ÁÒ»×Ö½ÚÊý¾Ý
|
//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;
|
}
|
//ÔÚmir3daÖ¸¶¨µØַдÈëÒ»¸öÊý¾Ý
|
//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);
|
|
}
|
//ÔÚAT24CXXÀïÃæµÄÖ¸¶¨µØÖ·¿ªÊ¼Ð´È볤¶ÈΪLenµÄÊý¾Ý
|
//¸Ãº¯ÊýÓÃÓÚдÈë16bit»òÕß32bitµÄÊý¾Ý.
|
//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);
|
}
|
}
|
|
//ÔÚAT24CXXÀïÃæµÄÖ¸¶¨µØÖ·¿ªÊ¼¶Á³ö³¤¶ÈΪLenµÄÊý¾Ý
|
//¸Ãº¯ÊýÓÃÓÚ¶Á³ö16bit»òÕß32bitµÄÊý¾Ý.
|
//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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_ReadReg
|
* Description : Generic Reading function. It must be fullfilled with either
|
* : 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_WriteReg
|
* Description : Generic Writing function. It must be fullfilled with either
|
* : I2C or SPI writing function
|
* Input : Register Address, Data to be written
|
* Output : None
|
* 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;
|
}
|
|
/* Private functions ---------------------------------------------------------*/
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_GetWHO_AM_I
|
* Description : Read identification code by WHO_AM_I register
|
* Input : Char to empty by Device identification Value
|
* 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;
|
|
return MEMS_SUCCESS;
|
}
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_GetStatusAUX
|
* Description : Read the AUX status register
|
* Input : Char to empty by status register buffer
|
* Output : None
|
* 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;
|
}
|
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_GetStatusAUXBIT
|
* Description : Read the AUX status register BIT
|
* Input : LIS3DH_STATUS_AUX_321OR, LIS3DH_STATUS_AUX_3OR, LIS3DH_STATUS_AUX_2OR, LIS3DH_STATUS_AUX_1OR,
|
LIS3DH_STATUS_AUX_321DA, LIS3DH_STATUS_AUX_3DA, LIS3DH_STATUS_AUX_2DA, LIS3DH_STATUS_AUX_1DA
|
* Output : None
|
* 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) )
|
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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetODR
|
* Description : Sets LIS3DH Output Data Rate
|
* Input : Output Data Rate
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetTemperature
|
* 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
|
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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetADCAux
|
* Description : Sets LIS3DH Output ADC
|
* Input : MEMS_ENABLE, MEMS_DISABLE
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_GetAuxRaw
|
* Description : Read the Aux Values Output Registers
|
* Input : Buffer to empty
|
* Output : Aux Values Registers buffer
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_GetTempRaw
|
* Description : Read the Temperature Values by AUX Output Registers OUT_3_H
|
* Input : Buffer to empty
|
* Output : Temperature Values Registers buffer
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetMode
|
* Description : Sets LIS3DH Operating Mode
|
* Input : Modality (LIS3DH_NORMAL, LIS3DH_LOW_POWER, LIS3DH_POWER_DOWN)
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetAxis
|
* Description : Enable/Disable LIS3DH Axis
|
* Input : LIS3DH_X_ENABLE/DISABLE | LIS3DH_Y_ENABLE/DISABLE | LIS3DH_Z_ENABLE/DISABLE
|
* Output : None
|
* Note : You MUST use all input variable in the argument, as example
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetFullScale
|
* Description : Sets the LIS3DH FullScale
|
* Input : LIS3DH_FULLSCALE_2/LIS3DH_FULLSCALE_4/LIS3DH_FULLSCALE_8/LIS3DH_FULLSCALE_16
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetBDU
|
* Description : Enable/Disable Block Data Update Functionality
|
* Input : ENABLE/DISABLE
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetBLE
|
* Description : Set Endianess (MSB/LSB)
|
* Input : BLE_LSB / BLE_MSB
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetSelfTest
|
* Description : Set Self Test Modality
|
* Input : LIS3DH_SELF_TEST_DISABLE/ST_0/ST_1
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_HPFClick
|
* Description : Enable/Disable High Pass Filter for click
|
* Input : MEMS_ENABLE/MEMS_DISABLE
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_HPFAOI1
|
* Description : Enable/Disable High Pass Filter for AOI on INT_1
|
* Input : MEMS_ENABLE/MEMS_DISABLE
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_HPFAOI2
|
* Description : Enable/Disable High Pass Filter for AOI on INT_2
|
* Input : MEMS_ENABLE/MEMS_DISABLE
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetHPFMode
|
* Description : Set High Pass Filter Modality
|
* Input : LIS3DH_HPM_NORMAL_MODE_RES/LIS3DH_HPM_REF_SIGNAL/
|
LIS3DH_HPM_NORMAL_MODE/LIS3DH_HPM_AUTORESET_INT
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetHPFCutOFF
|
* Description : Set High Pass CUT OFF Freq
|
* Input : HPFCF [0,3]
|
* Output : None
|
* 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;
|
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetFilterDataSel
|
* Description : Set Filter Data Selection bypassed or sent to FIFO OUT register
|
* Input : MEMS_SET, MEMS_RESET
|
* Output : None
|
* 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;
|
|
}
|
|
|
/*******************************************************************************
|
* 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 |
|
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 )
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* 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 |
|
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 |
|
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;
|
}
|
|
|
/*******************************************************************************
|
* 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 |
|
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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetClickTHS
|
* Description : Set Click Interrupt threshold
|
* Input : Click-click Threshold value [0-127]
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetClickLIMIT
|
* Description : Set Click Interrupt Time Limit
|
* Input : Click-click Time Limit value [0-127]
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetClickLATENCY
|
* Description : Set Click Interrupt Time Latency
|
* Input : Click-click Time Latency value [0-255]
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetClickWINDOW
|
* Description : Set Click Interrupt Time Window
|
* Input : Click-click Time Window value [0-255]
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_GetClickResponse
|
* Description : Get Click Interrupt Response by CLICK_SRC REGISTER
|
* Input : char to empty by Click Response Typedef
|
* Output : None
|
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
|
*******************************************************************************/
|
status_t LIS3DH_GetClickResponse(uint8_t* res) {
|
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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_Int1LatchEnable
|
* Description : Enable Interrupt 1 Latching function
|
* Input : ENABLE/DISABLE
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_ResetInt1Latch
|
* Description : Reset Interrupt 1 Latching function
|
* Input : None
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetIntConfiguration
|
* Description : Interrupt 1 Configuration (without LIS3DH_6D_INT)
|
* Input : LIS3DH_INT1_AND/OR | LIS3DH_INT1_ZHIE_ENABLE/DISABLE | LIS3DH_INT1_ZLIE_ENABLE/DISABLE...
|
* Output : None
|
* Note : You MUST use all input variable in the argument, as example
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* 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,
|
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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetInt6D4DConfiguration
|
* Description : 6D, 4D Interrupt Configuration
|
* Input : LIS3DH_INT1_6D_ENABLE, LIS3DH_INT1_4D_ENABLE, LIS3DH_INT1_6D_4D_DISABLE
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_Get6DPosition
|
* Description : 6D, 4D Interrupt Position Detect
|
* Input : Byte to empty by POSITION_6D_t Typedef
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetInt1Threshold
|
* Description : Sets Interrupt 1 Threshold
|
* Input : Threshold = [0,31]
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetInt1Duration
|
* Description : Sets Interrupt 1 Duration
|
* Input : Duration value
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_FIFOModeEnable
|
* Description : Sets Fifo Modality
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetTriggerInt
|
* Description : Trigger event liked to trigger signal INT1/INT2
|
* Input : LIS3DH_TRIG_INT1/LIS3DH_TRIG_INT2
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetWaterMark
|
* Description : Sets Watermark Value
|
* Input : Watermark = [0,31]
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_GetStatusReg
|
* Description : Read the status register
|
* Input : char to empty by Status Reg Value
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* 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_DATAREADY_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) )
|
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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_GetAccAxesRaw
|
* Description : Read the Acceleration Values Output Registers
|
* Input : buffer to empity by AxesRaw_t Typedef
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_GetInt1Src
|
* Description : Reset Interrupt 1 Latching function
|
* Input : Char to empty by Int1 source value
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_GetInt1SrcBit
|
* Description : Reset Interrupt 1 Latching function
|
* Input : statusBIT: LIS3DH_INT_SRC_IA, LIS3DH_INT_SRC_ZH, LIS3DH_INT_SRC_ZL.....
|
* val: Byte to be filled with the status bit
|
* Output : None
|
* 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;
|
}
|
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;
|
}
|
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;
|
}
|
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;
|
}
|
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;
|
}
|
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;
|
}
|
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;
|
}
|
else {
|
*val = MEMS_RESET;
|
return MEMS_SUCCESS;
|
}
|
}
|
return MEMS_ERROR;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_GetFifoSourceReg
|
* Description : Read Fifo source Register
|
* Input : Byte to empty by FIFO source register value
|
* Output : None
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_GetFifoSourceBit
|
* Description : Read Fifo WaterMark source bit
|
* Input : statusBIT: LIS3DH_FIFO_SRC_WTM, LIS3DH_FIFO_SRC_OVRUN, LIS3DH_FIFO_SRC_EMPTY
|
* val: Byte to fill with the bit value
|
* 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) )
|
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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_GetFifoSourceFSS
|
* Description : Read current number of unread samples stored in FIFO
|
* Input : Byte to empty by FIFO unread sample value
|
* 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;
|
}
|
|
|
/*******************************************************************************
|
* Function Name : LIS3DH_SetSPIInterface
|
* Description : Set SPI mode: 3 Wire Interface OR 4 Wire Interface
|
* Input : LIS3DH_SPI_3_WIRE, LIS3DH_SPI_4_WIRE
|
* Output : None
|
* 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;
|
}
|
/******************* (C) COPYRIGHT 2012 STMicroelectronics *****END OF FILE****/
|
