Skip to content
Projects
Groups
Snippets
Help
Loading...
Sign in
Toggle navigation
F
fwatch
Project
Project
Details
Activity
Cycle Analytics
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Charts
Issues
8
Issues
8
List
Board
Labels
Milestones
Merge Requests
0
Merge Requests
0
Wiki
Wiki
image/svg+xml
Discourse
Discourse
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Charts
Create a new issue
Commits
Issue Boards
Open sidebar
Projects
fwatch
Commits
0b340388
Commit
0b340388
authored
Oct 11, 2014
by
Projects
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
Removed unused files.
parent
abe6c716
Hide whitespace changes
Inline
Side-by-side
Showing
7 changed files
with
0 additions
and
3296 deletions
+0
-3296
LSM303C_ACC_driver.c
sw/common/drivers/LSM303C/LSM303C_ACC_driver.c
+0
-1147
LSM303C_ACC_driver.h
sw/common/drivers/LSM303C/LSM303C_ACC_driver.h
+0
-437
LSM303C_MAG_driver.c
sw/common/drivers/LSM303C/LSM303C_MAG_driver.c
+0
-942
LSM303C_MAG_driver.h
sw/common/drivers/LSM303C/LSM303C_MAG_driver.h
+0
-367
cpu_calls2.c
sw/common/drivers/LSM303C/cpu_calls2.c
+0
-274
pp-printf.h
sw/common/pp_printf/pp-printf.h
+0
-8
vsprintf-xint.c
sw/common/pp_printf/vsprintf-xint.c
+0
-121
No files found.
sw/common/drivers/LSM303C/LSM303C_ACC_driver.c
deleted
100644 → 0
View file @
abe6c716
/******************** (C) COPYRIGHT 2013 STMicroelectronics ********************
* File Name : LSM303C_ACC.c
* Author : MSH Application Team
* Author : $Author:$
* Version : rev 1.0
* Date : $Date:$
* Description : LSM303C_ACC driver file
*
* HISTORY:
* Date | Modification | Author
* 09/2012 | Initial Revision | Alberto Zancanato
*
********************************************************************************
* 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 "LSM303C_ACC_driver.h"
#include "lsm303c.h"
//EXAMPLE to fill LSM303C_ACC_ReadReg and LSM303C_ACC_WriteReg
//#include "i2C_mems.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/*******************************************************************************
* Function Name : LSM303C_ACC_ReadReg
* Description : Generic Reading function. It must be fullfilled with either
* : I2C or SPI reading functions
* Input : Register Address
* Output : Data REad
* Return : None
*******************************************************************************/
u8_t
LSM303C_ACC_ReadReg
(
u8_t
Reg
,
u8_t
*
Data
)
{
return
spi_read
(
DEV_ACC
,
Reg
,
Data
);
}
/*******************************************************************************
* Function Name : LSM303C_ACC_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
*******************************************************************************/
u8_t
LSM303C_ACC_WriteReg
(
u8_t
Reg
,
u8_t
Data
)
{
spi_send
(
DEV_ACC
,
Reg
,
Data
);
return
1
;
}
/* Private functions ---------------------------------------------------------*/
/*******************************************************************************
* Function Name : LSM303C_ACC_SelfTest
* Description : Enable/Disable LSM303C_ACC Self Test
* Input : Self test [LSM303C_ACC_ST_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_SelfTest
(
LSM303C_ACC_ST_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL5
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_ST_NA
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL5
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_SetODR
* Description : Sets LSM303C_ACC Output Data Rate
* Input : Set Output data rate [LSM303C_ACC_ODR_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_SetODR
(
LSM303C_ACC_ODR_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL1
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_ODR_MASK
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL1
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_AxOperativeMode
* Description : Sets LSM303C_ACC Output Data Rate
* Input : Set Output data rate [LSM303C_ACC_HR_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//#WARNING: If you enable the HR bit Low pass cut off frequency will change
status_t
LSM303C_ACC_AxOperativeMode
(
LSM303C_ACC_HR_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL1
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_HIGH_RES_ON
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL1
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_SoftReset
* Description : Enable/Disable LSM303C_ACC SoftReset
* Input : SoftReset Enable/Disable [LSM303C_ACC_SOFT_RESET_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_SoftReset
(
LSM303C_ACC_SOFT_RESET_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL5
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_SOFT_RESET_ENABLE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL5
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_SetFullScale
* Description : set LSM303C_ACC Full scale
* Input : set LSM303C_ACC Full scale [LSM303C_ACC_FS_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_SetFullScale
(
LSM303C_ACC_FS_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL4
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_FS_8g
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL4
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_SerialInterfaceMode
* Description : set LSM303C_ACC SerialInterfaceMode
* Input : set LSM303C_ACC SerialInterfaceMode [LSM303C_ACC_SIM_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_SerialInterfaceMode
(
LSM303C_ACC_SIM_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL4
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_SIM_3WIRE_INTERFACE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL4
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_BlockDataUpdate
* Description : Enable/Disable LSM303C_ACC BlockDataUpdate
* Input : Enable/Disable LSM303C_ACC BlockDataUpdate[LSM303C_ACC_BDU_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_BlockDataUpdate
(
LSM303C_ACC_BDU_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL1
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_BDU_ENABLE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL1
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_EnableInterruptGeneratorOne
* Description : Enable/Disable LSM303C_ACC interrupt generator one
* Input : Enable/Disable LSM303C_ACC interrupt generator one[LSM303C_ACC_IG_CONFIG_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//You can use LSM303C_ACC_IG_CONFIG_t with or condition see DS 4D and 6D interrupt
status_t
LSM303C_ACC_EnableInterruptGeneratorOne
(
LSM303C_ACC_IG_CONFIG_t
ov
){
u8_t
valueCTRL7
,
valueCFG1
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL7
,
&
valueCTRL7
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_IG_CFG1
,
&
valueCFG1
)
)
return
MEMS_ERROR
;
if
(
ov
&
LSM303C_ACC_IG_4D
)
{
valueCFG1
&=
0x80
;
//disable all interrupt generation
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_IG_CFG1
,
valueCFG1
)
)
return
MEMS_ERROR
;
valueCTRL7
|=
LSM303C_ACC_4D_INTGEN1_EN
;
//enable 4D recognition
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL7
,
valueCTRL7
)
)
return
MEMS_ERROR
;
}
else
{
valueCFG1
&=
~
0x7F
;
//enable selected interrupt
valueCFG1
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_IG_CFG1
,
valueCFG1
)
)
return
MEMS_ERROR
;
valueCTRL7
&=
~
LSM303C_ACC_4D_INTGEN1_EN
;
//disable 4d recognition
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL7
,
valueCTRL7
)
)
return
MEMS_ERROR
;
}
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_EnableInterruptGeneratorTwo
* Description : Enable/Disable LSM303C_ACC interrupt generator two
* Input : Enable/Disable LSM303C_ACC interrupt generator two[LSM303C_ACC_IG_CONFIG_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//You can use LSM303C_ACC_IG_CONFIG_t with or condition see DS 4D and 6D interrupt
status_t
LSM303C_ACC_EnableInterruptGeneratorTwo
(
LSM303C_ACC_IG_CONFIG_t
ov
){
u8_t
valueCTRL7
,
valueCFG2
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL7
,
&
valueCTRL7
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_IG_CFG2
,
&
valueCFG2
)
)
return
MEMS_ERROR
;
if
(
ov
&
LSM303C_ACC_IG_4D
)
{
valueCFG2
&=
0x80
;
//disable all interrupt generation
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_IG_CFG2
,
valueCFG2
)
)
return
MEMS_ERROR
;
valueCTRL7
|=
LSM303C_ACC_4D_INTGEN2_EN
;
//enable 4D recognition
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL7
,
valueCTRL7
)
)
return
MEMS_ERROR
;
}
else
{
valueCFG2
&=
~
0x7F
;
//enable selected interrupt
valueCFG2
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_IG_CFG2
,
valueCFG2
)
)
return
MEMS_ERROR
;
valueCTRL7
&=
~
LSM303C_ACC_4D_INTGEN2_EN
;
//disable 4d recognition
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL7
,
valueCTRL7
)
)
return
MEMS_ERROR
;
}
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_InterruptGeneratorOne_LogicCondition
* Description : LSM303C_ACC interrupt generator one LogicCondition
* Input : LSM303C_ACC interrupt generator one LogicCondition[LSM303C_ACC_AOI_IG_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_InterruptGeneratorOne_LogicCondition
(
LSM303C_ACC_AOI_IG_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_IG_CFG1
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_AOI_IG_AND
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_IG_CFG1
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_InterruptGeneratorTwo_LogicCondition
* Description : LSM303C_ACC interrupt generator two LogicCondition
* Input : LSM303C_ACC interrupt generator two LogicCondition[LSM303C_ACC_AOI_IG_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_InterruptGeneratorTwo_LogicCondition
(
LSM303C_ACC_AOI_IG_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_IG_CFG2
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_AOI_IG_AND
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_IG_CFG2
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_InterruptGeneratorOne_Flag
* Description : read interrupt one generator flags
* Input : pointer to LSM303C_ACC_IG_FLAGS_t
* Output : LSM303C_ACC XYZ Axis data overrun [LSM303C_ACC_IG_FLAGS_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//You can use LSM303C_ACC_IG_FLAGS_t with or condition to interpret value
status_t
LSM303C_ACC_InterruptGeneratorOne_Flag
(
LSM303C_ACC_IG_FLAGS_t
*
value
){
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_IG_SRC1
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
0x7F
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_InterruptGeneratorTwo_Flag
* Description : read interrupt two generator flags
* Input : pointer to LSM303C_ACC_IG_FLAGS_t
* Output : LSM303C_ACC XYZ Axis data overrun [LSM303C_ACC_IG_FLAGS_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//You can use LSM303C_ACC_IG_FLAGS_t with or condition to interpret value
status_t
LSM303C_ACC_InterruptGeneratorTwo_Flag
(
LSM303C_ACC_IG_FLAGS_t
*
value
){
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_IG_SRC2
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
0x7F
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_InterruptGeneratorOne_Wait
* Description : Enable/Disable LSM303C_ACC interrupt generator one Wait
* Input : Enable/Disable LSM303C_ACC interrupt generator one Wait[LSM303C_ACC_WAIT_IG_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_InterruptGeneratorOne_Wait
(
LSM303C_ACC_WAIT_IG_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_IG_DUR1
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_WAIT_IG_ON
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_IG_DUR1
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_InterruptGeneratorTwo_Wait
* Description : Enable/Disable LSM303C_ACC interrupt generator two Wait
* Input : Enable/Disable LSM303C_ACC interrupt generator two Wait[LSM303C_ACC_WAIT_IG_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_InterruptGeneratorTwo_Wait
(
LSM303C_ACC_WAIT_IG_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_IG_DUR2
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_WAIT_IG_ON
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_IG_DUR2
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_EnableInterruptPinOne
* Description : Enable/Disable LSM303C_ACC interrupt pin one
* Input : Enable/Disable LSM303C_ACC interrupt pin one[LSM303C_ACC_INT1_DRDY_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_EnableInterruptPinOne
(
LSM303C_ACC_INT1_DRDY_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL3
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
0x7F
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL3
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_EnableInterruptPinTwo
* Description : Enable/Disable LSM303C_ACC interrupt pin two
* Input : Enable/Disable LSM303C_ACC interrupt pin two[LSM303C_ACC_INT2_DRDY_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_EnableInterruptPinTwo
(
LSM303C_ACC_INT2_DRDY_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL6
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
0x3F
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL6
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_Reboot
* Description : LSM303C_ACC_Reboot
* Input : None
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_Reboot
(
void
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL6
,
&
value
)
)
return
MEMS_ERROR
;
value
|=
LSM303C_ACC_REBOOT
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL6
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_EnableAxis
* Description : LSM303C_ACC_EnableAxis
* Input : Enable/Disable LSM303C_ACC axis [LSM303C_ACC_AXIS_EN_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//You can use LSM303C_ACC_AXIS_EN_t with or condition
status_t
LSM303C_ACC_EnableAxis
(
u8_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL1
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
0x07
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL1
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_HighPassFilterMode
* Description : LSM303C_ACC_HighPassFilterMode
* Input : Select LSM303C_ACC high pass filter mode [LSM303C_ACC_HPM_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//Referring DS to HP filter Usage
status_t
LSM303C_ACC_HighPassFilterMode
(
LSM303C_ACC_HPM_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL2
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
0x18
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL2
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_I2C_Mode
* Description : Enable/Disable LSM303C_ACC I2C
* Input : Enable/Disable LSM303C_ACC I2C[LSM303C_ACC_I2C_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_I2C_Mode
(
LSM303C_ACC_I2C_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL4
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_I2C_DISABLE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL4
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_AuotoInc
* Description : Enable/Disable LSM303C_ACC AuotoInc
* Input : Enable/Disable LSM303C_ACC AuotoInc[LSM303C_ACC_IF_ADD_INC_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_AuotoInc
(
LSM303C_ACC_IF_ADD_INC_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL4
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_IF_ADD_INC_ENABLE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL4
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_Select_Bandwidth
* Description : LSM303C_ACC LSM303C_ACC_Select_Bandwidth
* Input : LSM303C_ACC LSM303C_ACC_Select_Bandwidth[LSM303C_ACC_BW_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_Select_Bandwidth
(
LSM303C_ACC_BW_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL4
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_BW_50_Hz
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL4
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_IntPin_Mode
* Description : LSM303C_ACC Interrupt pin mode
* Input : LSM303C_ACC Interrupt pin mode[LSM303C_ACC_INT_PIN_CFG_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_IntPin_Mode
(
LSM303C_ACC_INT_PIN_CFG_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL5
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_OPEN_DRAIN_ACTIVE_LOW
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL5
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_DebugMode
* Description : Enable/Disable LSM303C_ACC Debug Mode
* Input : Enable/Disable LSM303C_ACC Debug Mode[LSM303C_ACC_DEBUG_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_DebugMode
(
LSM303C_ACC_DEBUG_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL5
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_DEBUG_ENABLE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL5
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_InterruptSignalsMode
* Description : LSM303C_ACC Interrupt Signals Mode
* Input : LSM303C_ACC Interrupt Signals Mode[LSM303C_ACC_LAT_SIG_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_InterruptSignalsMode
(
LSM303C_ACC_LAT_SIG_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL7
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_INT1_LAT_INT2_LAT
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL7
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_ResetInterruptDuration
* Description : LSM303C_ACC Reset Interrupt Duration
* Input : LSM303C_ACC Reset Interrupt Duration[LSM303C_ACC_RESET_DUR_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_ResetInterruptDuration
(
LSM303C_ACC_RESET_DUR_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL7
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_DUR1_RST_DUR2_RST
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL7
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_Status_Flags
* Description : read LSM303C_ACC Status Flags
* Input : pointer to LSM303C_ACC_STATUS_FLAGS_t
* Output : read LSM303C_ACC Status Flags [LSM303C_ACC_STATUS_FLAGS_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//You can use LSM303C_ACC_STATUS_FLAGS_t with or condition to interpret value
status_t
LSM303C_ACC_Status_Flags
(
u8_t
*
value
){
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_STATUS
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_FIFO_Mode
* Description : LSM303C_ACC FIFO Mode
* Input : LSM303C_ACC FIFO Mode[LSM303C_ACC_FMODE_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//this function enable FIFO to disable use LSM303C_ACC_FIFO
status_t
LSM303C_ACC_FIFO_Mode
(
LSM303C_ACC_FMODE_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL3
,
&
value
)
)
return
MEMS_ERROR
;
value
|=
LSM303C_ACC_FIFO_ENABLE
;
//Enable FIFO
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL3
,
value
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_FIFO_CTRL
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_FMODE_BYPASS_TO_FIFO
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_FIFO_CTRL
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_FIFO_Flags
* Description : read LSM303C_ACC FIFO Flags
* Input : pointer to LSM303C_ACC_FIFO_FLAGS_t
* Output : read LSM303C_ACC FIFO Flags [LSM303C_ACC_FIFO_FLAGS_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//You can use LSM303C_ACC_FIFO_FLAGS_t with or condition to interpret value
status_t
LSM303C_ACC_FIFO_Flags
(
LSM303C_ACC_FIFO_FLAGS_t
*
value
){
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_FIFO_SRC
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
0xE0
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_FIFO_StopAtTh
* Description : LSM303C_ACC FIFO Stop at threshold
* Input : LSM303C_ACC FIFO Stop at threshold[LSM303C_ACC_STOP_FTH_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_FIFO_StopAtTh
(
LSM303C_ACC_STOP_FTH_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL3
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_STOP_FTH_EN_FIFO_TH
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL3
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_FIFO
* Description : Enable/Disable LSM303C_ACC FIFO
* Input : Enable/Disable LSM303C_ACC FIFO[LSM303C_ACC_FIFO_EN_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_FIFO
(
LSM303C_ACC_FIFO_EN_t
ov
){
u8_t
value
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_CTRL3
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_ACC_FIFO_ENABLE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_CTRL3
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_GetAccRaw
* Description : Read accelerometer output register
* Input : pointer to AxesRaw_t
* Output : Acceleration Output Registers buffer AxesRaw_t
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_GetAccRaw
(
AxesRaw_t
*
buff
)
{
u8_t
valueL
;
u8_t
valueH
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_OUT_X_H
,
&
valueH
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_OUT_X_L
,
&
valueL
)
)
return
MEMS_ERROR
;
buff
->
AXIS_X
=
(
i16_t
)(
(
valueH
<<
8
)
|
valueL
);
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_OUT_Y_H
,
&
valueH
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_OUT_Y_L
,
&
valueL
)
)
return
MEMS_ERROR
;
buff
->
AXIS_Y
=
(
i16_t
)(
(
valueH
<<
8
)
|
valueL
);
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_OUT_Z_H
,
&
valueH
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_OUT_Z_L
,
&
valueL
)
)
return
MEMS_ERROR
;
buff
->
AXIS_Z
=
(
i16_t
)(
(
valueH
<<
8
)
|
valueL
);
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_GetTemperatureRaw
* Description : Read Temperature output register
* Input : pointer to u16_t
* Output : Temperature data row to u16_t
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_GetTemperatureRaw
(
u16_t
*
buff
)
{
u8_t
valueL
;
u8_t
valueH
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_TEMP_H
,
&
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_TEMP_L
,
&
valueH
)
)
return
MEMS_ERROR
;
*
buff
=
(
i16_t
)(
(
valueH
<<
8
)
|
valueL
);
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_SetInterrupt1_Threshold_X
* Description : Set Interrupt Threshold data row
* Input : threshold row value [u8_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_SetInterrupt1_Threshold_X
(
u8_t
buff
)
{
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_IG_THS_X1
,
buff
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_SetInterrupt1_Threshold_Y
* Description : Set Interrupt Threshold data row
* Input : threshold row value [u8_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_SetInterrupt1_Threshold_Y
(
u8_t
buff
)
{
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_IG_THS_Y1
,
buff
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_SetInterrupt1_Threshold_Z
* Description : Set Interrupt Threshold data row
* Input : threshold row value [u8_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_SetInterrupt1_Threshold_Z
(
u8_t
buff
)
{
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_IG_THS_Z1
,
buff
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_SetInterrupt2_Threshold_ZYX
* Description : Set Interrupt Threshold data row
* Input : threshold row value [u8_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_SetInterrupt2_Threshold_ZYX
(
u8_t
buff
)
{
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_IG_THS2
,
buff
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_SetInterrupt1_Duration
* Description : Set Interrupt Duration data row
* Input : Duration row value [u8_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//WARNING: value from 0x00->0x7F
status_t
LSM303C_ACC_SetInterrupt1_Duration
(
u8_t
buff
)
{
u8_t
value
;
buff
|=
0x7F
;
//coerce
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_IG_DUR1
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
0x7F
;
//mask
value
|=
buff
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_IG_DUR1
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_SetInterrupt2_Duration
* Description : Set Interrupt Duration data row
* Input : Duration row value [u8_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//WARNING: value from 0x00->0x7F
status_t
LSM303C_ACC_SetInterrupt2_Duration
(
u8_t
buff
)
{
u8_t
value
;
buff
|=
0x7F
;
//coerce
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_IG_DUR2
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
0x7F
;
//mask
value
|=
buff
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_IG_DUR2
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_SetReferenceValue
* Description : Set Reference data row
* Input : Reference row value [AxesRaw_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_SetReferenceValue
(
AxesRaw_t
buff
)
{
u8_t
valueL
;
u8_t
valueH
;
valueL
=
buff
.
AXIS_X
&
0x00FF
;
valueH
=
buff
.
AXIS_X
&
0xFF00
>>
8
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_XL_REFERENCE
,
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_XH_REFERENCE
,
valueH
)
)
return
MEMS_ERROR
;
valueL
=
buff
.
AXIS_Y
&
0x00FF
;
valueH
=
buff
.
AXIS_Y
&
0xFF00
>>
8
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_YL_REFERENCE
,
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_YH_REFERENCE
,
valueH
)
)
return
MEMS_ERROR
;
valueL
=
buff
.
AXIS_Z
&
0x00FF
;
valueH
=
buff
.
AXIS_Z
&
0xFF00
>>
8
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_ZL_REFERENCE
,
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_ZH_REFERENCE
,
valueH
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_GetReferenceValue
* Description : Get Reference data row
* Input : Reference row value [AxesRaw_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_GetReferenceValue
(
AxesRaw_t
*
buff
)
{
u8_t
valueL
;
u8_t
valueH
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_XL_REFERENCE
,
&
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_XH_REFERENCE
,
&
valueH
)
)
return
MEMS_ERROR
;
buff
->
AXIS_X
=
(
i16_t
)(
(
valueH
<<
8
)
|
valueL
);
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_YL_REFERENCE
,
&
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_YH_REFERENCE
,
&
valueH
)
)
return
MEMS_ERROR
;
buff
->
AXIS_Y
=
(
i16_t
)(
(
valueH
<<
8
)
|
valueL
);
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_ZL_REFERENCE
,
&
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_ZH_REFERENCE
,
&
valueH
)
)
return
MEMS_ERROR
;
buff
->
AXIS_Z
=
(
i16_t
)(
(
valueH
<<
8
)
|
valueL
);
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_SetActivity_Threshold
* Description : Set Interrupt Threshold data row
* Input : threshold row value [u8_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_SetActivity_Threshold
(
u8_t
buff
)
{
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_ACT_TSH
,
buff
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_SetActivity_Duration
* Description : Set Interrupt Threshold data row
* Input : threshold row value [u8_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_ACC_SetActivity_Duration
(
u8_t
buff
)
{
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_ACT_DUR
,
buff
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_SetFIFO_threshold
* Description : FIFO Threshold data row
* Input : threshold row value [u8_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//WARNING: value from 0x00->0x1F
status_t
LSM303C_ACC_SetFIFO_threshold
(
u8_t
buff
)
{
u8_t
value
;
buff
&=
0x1F
;
//coerce
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_FIFO_CTRL
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
0x1F
;
//mask
value
|=
buff
;
if
(
!
LSM303C_ACC_WriteReg
(
LSM303C_ACC_FIFO_CTRL
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_ACC_GetFIFO_StoredData
* Description : FIFO Stored data row
* Input : Stored data row value [u8_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//WARNING: value from 0x00->0x1F
status_t
LSM303C_ACC_GetFIFO_StoredData
(
u8_t
buff
)
{
if
(
!
LSM303C_ACC_ReadReg
(
LSM303C_ACC_FIFO_SRC
,
&
buff
)
)
return
MEMS_ERROR
;
buff
&=
0x1F
;
//coerce
return
MEMS_SUCCESS
;
}
sw/common/drivers/LSM303C/LSM303C_ACC_driver.h
deleted
100644 → 0
View file @
abe6c716
/******************** (C) COPYRIGHT 2013 STMicroelectronics ********************
* File Name : LSM303C_ACC_driver.h
* Author : MSH Application Team
* Author : $Author:$
* Version : rev 1.0
* Date : $Date:$
* Description : Descriptor Header for LSM303C_ACC driver file
*
* HISTORY:
* 09/17/2013 Automatically Generated
* Date | Modification | Author
* 09/2012 | Initial Revision | Alberto Zancanato
*
********************************************************************************
* 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.
*
*******************************************************************************/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __LSM303C_ACC_DRIVER__H
#define __LSM303C_ACC_DRIVER__H
/* Includes ------------------------------------------------------------------*/
/* Exported types ------------------------------------------------------------*/
//these could change accordingly with the architecture
#ifndef __ARCHDEP__TYPES
#define __ARCHDEP__TYPES
typedef
unsigned
char
u8_t
;
typedef
unsigned
short
int
u16_t
;
typedef
short
int
i16_t
;
typedef
signed
char
i8_t
;
#endif
/*__ARCHDEP__TYPES*/
/* Exported common structure --------------------------------------------------------*/
#ifndef __SHARED__TYPES
#define __SHARED__TYPES
typedef
enum
{
MEMS_SUCCESS
=
0x01
,
MEMS_ERROR
=
0x00
}
status_t
;
typedef
enum
{
MEMS_ENABLE
=
0x01
,
MEMS_DISABLE
=
0x00
}
State_t
;
typedef
struct
{
i16_t
AXIS_X
;
i16_t
AXIS_Y
;
i16_t
AXIS_Z
;
}
AxesRaw_t
;
typedef
u8_t
IntPinConf_t
;
typedef
u8_t
Axis_t
;
typedef
u8_t
IntConf_t
;
#endif
/*__SHARED__TYPES*/
/* Exported device structure --------------------------------------------------------*/
//You can use LSM303C_ACC_AXIS_EN_t with or condition
typedef
enum
{
LSM303C_ACC_DISABLE_ALL
=
0x00
,
LSM303C_ACC_X_ENABLE
=
0x01
,
LSM303C_ACC_Y_ENABLE
=
0x02
,
LSM303C_ACC_Z_ENABLE
=
0x04
}
LSM303C_ACC_AXIS_EN_t
;
typedef
enum
{
LSM303C_ACC_BDU_DISABLE
=
0x00
,
LSM303C_ACC_BDU_ENABLE
=
0x08
}
LSM303C_ACC_BDU_t
;
typedef
enum
{
LSM303C_ACC_ODR_POWER_DOWN
=
0x00
,
LSM303C_ACC_ODR_10_Hz
=
0x10
,
LSM303C_ACC_ODR_50_Hz
=
0x20
,
LSM303C_ACC_ODR_100_Hz
=
0x30
,
LSM303C_ACC_ODR_200_Hz
=
0x40
,
LSM303C_ACC_ODR_400_Hz
=
0x50
,
LSM303C_ACC_ODR_800_Hz
=
0x60
,
LSM303C_ACC_ODR_MASK
=
0x60
}
LSM303C_ACC_ODR_t
;
typedef
enum
{
LSM303C_ACC_HIGH_RES_OFF
=
0x00
,
LSM303C_ACC_HIGH_RES_ON
=
0x80
}
LSM303C_ACC_HR_t
;
typedef
enum
{
LSM303C_ACC_HP_INT1_DIS
=
0x00
,
LSM303C_ACC_HP_INT1_EN
=
0x01
}
LSM303C_ACC_HPIS_INT1_t
;
typedef
enum
{
LSM303C_ACC_HP_INT2_DIS
=
0x00
,
LSM303C_ACC_HP_INT2_EN
=
0x02
}
LSM303C_ACC_HPIS_INT2_t
;
typedef
enum
{
LSM303C_ACC_FDS_BYPASS
=
0x00
,
LSM303C_ACC_FDS_FILTER
=
0x04
}
LSM303C_ACC_FDS_t
;
//Referring DS to HP filter Usage
typedef
enum
{
LSM303C_ACC_HPM_NORMAL_MODE
=
0x00
,
LSM303C_ACC_HPM_REF_FOR_FILT
=
0x08
}
LSM303C_ACC_HPM_t
;
//Referring DS to HP filter Usage
typedef
enum
{
LSM303C_ACC_DFC_ODR_DIV_50
=
0x00
,
LSM303C_ACC_DFC_ODR_DIV_100
=
0x20
,
LSM303C_ACC_DFC_ODR_DIV_9
=
0x40
,
LSM303C_ACC_DFC_ODR_DIV_400
=
0x60
}
LSM303C_ACC_DFC_t
;
typedef
enum
{
LSM303C_ACC_INT1_DISABLE
=
0x00
,
LSM303C_ACC_INT1_DRDY
=
0x01
,
LSM303C_ACC_INT1_FIFO_TH
=
0x02
,
LSM303C_ACC_INT1_FIFO_OVR
=
0x00
,
LSM303C_ACC_INT1_INTGEN1
=
0x08
,
LSM303C_ACC_INT1_INTGEN2
=
0x10
,
LSM303C_ACC_INT1_INACTIVITY
=
0x20
}
LSM303C_ACC_INT1_DRDY_t
;
typedef
enum
{
LSM303C_ACC_INT2_DISABLE
=
0x00
,
LSM303C_ACC_INT2_DRDY
=
0x01
,
LSM303C_ACC_INT2_FIFO_TH
=
0x02
,
LSM303C_ACC_INT2_FIFO_EMPTY
=
0x00
,
LSM303C_ACC_INT2_INTGEN1
=
0x08
,
LSM303C_ACC_INT2_INTGEN2
=
0x10
,
LSM303C_ACC_INT2_BOOT
=
0x20
}
LSM303C_ACC_INT2_DRDY_t
;
typedef
enum
{
LSM303C_ACC_REBOOT
=
0x80
}
LSM303C_ACC_INT2_INTGEN2_t
;
typedef
enum
{
LSM303C_ACC_SIM_4WIRE_INTERFACE
=
0x00
,
LSM303C_ACC_SIM_3WIRE_INTERFACE
=
0x01
}
LSM303C_ACC_SIM_t
;
typedef
enum
{
LSM303C_ACC_I2C_ENABLE
=
0x00
,
LSM303C_ACC_I2C_DISABLE
=
0x02
}
LSM303C_ACC_I2C_t
;
typedef
enum
{
LSM303C_ACC_IF_ADD_INC_DISABLE
=
0x00
,
LSM303C_ACC_IF_ADD_INC_ENABLE
=
0x04
}
LSM303C_ACC_IF_ADD_INC_t
;
typedef
enum
{
LSM303C_ACC_FS_2g
=
0x00
,
LSM303C_ACC_FS_4g
=
0x20
,
LSM303C_ACC_FS_8g
=
0x30
}
LSM303C_ACC_FS_t
;
typedef
enum
{
LSM303C_ACC_BW_400_Hz
=
0x08
,
LSM303C_ACC_BW_200_Hz
=
0x48
,
LSM303C_ACC_BW_100_Hz
=
0x88
,
LSM303C_ACC_BW_50_Hz
=
0xC8
}
LSM303C_ACC_BW_t
;
typedef
enum
{
LSM303C_ACC_PUSH_PULL_ACTIVE_HIGH
=
0x00
,
LSM303C_ACC_OPEN_DRAIN_ACTIVE_HIGH
=
0x01
,
LSM303C_ACC_PUSH_PULL_ACTIVE_LOW
=
0x02
,
LSM303C_ACC_OPEN_DRAIN_ACTIVE_LOW
=
0x03
}
LSM303C_ACC_INT_PIN_CFG_t
;
typedef
enum
{
LSM303C_ACC_ST_DISABLE
=
0x00
,
LSM303C_ACC_ST_POSITIVE
=
0x04
,
LSM303C_ACC_ST_NEGATIVE
=
0x08
,
LSM303C_ACC_ST_NA
=
0x0C
}
LSM303C_ACC_ST_t
;
typedef
enum
{
LSM303C_ACC_DEC_DISABLE
=
0x00
,
LSM303C_ACC_DEC_2_SAMPLES
=
0x10
,
LSM303C_ACC_DEC_4_SAMPLES
=
0x20
,
LSM303C_ACC_DEC_8_SAMPLES
=
0x30
}
LSM303C_ACC_DEC_t
;
typedef
enum
{
LSM303C_ACC_SOFT_RESET_DISABLE
=
0x00
,
LSM303C_ACC_SOFT_RESET_ENABLE
=
0x40
}
LSM303C_ACC_SOFT_RESET_t
;
typedef
enum
{
LSM303C_ACC_DEBUG_DISABLE
=
0x00
,
LSM303C_ACC_DEBUG_ENABLE
=
0x80
}
LSM303C_ACC_DEBUG_t
;
typedef
enum
{
LSM303C_ACC_INT1_PULS_INT2_PULS
=
0x00
,
LSM303C_ACC_INT1_LAT_INT2_PULS
=
0x04
,
LSM303C_ACC_INT1_PULS_INT2_LAT
=
0x08
,
LSM303C_ACC_INT1_LAT_INT2_LAT
=
0x0C
}
LSM303C_ACC_LAT_SIG_t
;
typedef
enum
{
LSM303C_ACC_DUR1_NORST_DUR2_NORST
=
0x00
,
LSM303C_ACC_DUR1_RST_DUR2_NORST
=
0x10
,
LSM303C_ACC_DUR1_NORST_DUR2_RST
=
0x20
,
LSM303C_ACC_DUR1_RST_DUR2_RST
=
0x30
}
LSM303C_ACC_RESET_DUR_t
;
//You can use this typedef with or condition
typedef
enum
{
LSM303C_ACC_IG1_ON_LOW_X_FLAG_UP
=
0x01
,
LSM303C_ACC_IG1_ON_HIGH_X_FLAG_UP
=
0x02
,
LSM303C_ACC_IG1_ON_LOW_Y_FLAG_UP
=
0x04
,
LSM303C_ACC_IG1_ON_HIGH_Y_FLAG_UP
=
0x08
,
LSM303C_ACC_IG1_ON_LOW_Z_FLAG_UP
=
0x10
,
LSM303C_ACC_IG1_ON_HIGH_Z_FLAG_UP
=
0x20
,
LSM303C_ACC_IA_IG1_FLAG_UP
=
0x40
}
LSM303C_ACC_IG_FLAGS_t
;
typedef
enum
{
LSM303C_ACC_X_NEW_DATA_AVAILABLE
=
0x01
,
LSM303C_ACC_Y_NEW_DATA_AVAILABLE
=
0x02
,
LSM303C_ACC_Z_NEW_DATA_AVAILABLE
=
0x04
,
LSM303C_ACC_ZYX_NEW_DATA_AVAILABLE
=
0x08
,
LSM303C_ACC_X_OVERRUN
=
0x10
,
LSM303C_ACC_Y_OVERRUN
=
0x20
,
LSM303C_ACC_Z_OVERRUN
=
0x40
,
LSM303C_ACC_ZYX_OVERRUN
=
0x80
}
LSM303C_ACC_STATUS_FLAGS_t
;
//You can use this typedef with or condition see DS 4D and 6D interrupt
typedef
enum
{
LSM303C_ACC_IG_DIS
=
0x00
,
LSM303C_ACC_IG_LOW_X
=
0x01
,
LSM303C_ACC_IG_HIGH_X
=
0x02
,
LSM303C_ACC_IG_LOW_Y_
=
0x04
,
LSM303C_ACC_IG_HIGH_Y
=
0x08
,
LSM303C_ACC_IG_LOW_Z
=
0x10
,
LSM303C_ACC_IG_HIGH_Z
=
0x20
,
LSM303C_ACC_IG_6D
=
0x40
,
LSM303C_ACC_IG_4D
=
0x80
}
LSM303C_ACC_IG_CONFIG_t
;
typedef
enum
{
LSM303C_ACC_4D_INTGEN1_DIS
=
0x00
,
LSM303C_ACC_4D_INTGEN1_EN
=
0x01
}
LSM303C_ACC_4D_INTGEN1_t
;
typedef
enum
{
LSM303C_ACC_4D_INTGEN2_DIS
=
0x00
,
LSM303C_ACC_4D_INTGEN2_EN
=
0x02
}
LSM303C_ACC_4D_INTGEN2_t
;
typedef
enum
{
LSM303C_ACC_AOI_IG_OR
=
0x00
,
LSM303C_ACC_AOI_IG_AND
=
0x80
}
LSM303C_ACC_AOI_IG_t
;
typedef
enum
{
LSM303C_ACC_WAIT_IG_OFF
=
0x00
,
LSM303C_ACC_WAIT_IG_ON
=
0x80
}
LSM303C_ACC_WAIT_IG_t
;
typedef
enum
{
LSM303C_ACC_FMODE_BYPASS
=
0x00
,
LSM303C_ACC_FMODE_STOP_WHEN_FULL
=
0x20
,
LSM303C_ACC_FMODE_STREAM
=
0x40
,
LSM303C_ACC_FMODE_STREAM_TO_FIFO
=
0x60
,
LSM303C_ACC_FMODE_BYPASS_TO_STREAM
=
0x80
,
LSM303C_ACC_FMODE_BYPASS_TO_FIFO
=
0xE0
}
LSM303C_ACC_FMODE_t
;
typedef
enum
{
LSM303C_ACC_FIFO_EMPTY_TRUE
=
0x20
,
LSM303C_ACC_OVR_FIFO_TRUE
=
0x40
,
LSM303C_ACC_FTH_PASS
=
0x80
}
LSM303C_ACC_FIFO_FLAGS_t
;
typedef
enum
{
LSM303C_ACC_STOP_FTH_DIS_FIFO_TH
=
0x00
,
LSM303C_ACC_STOP_FTH_EN_FIFO_TH
=
0x40
}
LSM303C_ACC_STOP_FTH_t
;
typedef
enum
{
LSM303C_ACC_FIFO_DISABLE
=
0x00
,
LSM303C_ACC_FIFO_ENABLE
=
0x80
}
LSM303C_ACC_FIFO_EN_t
;
#define LSM303C_ACC_WHO_AM_I 0x41
#define LSM303C_ACC_MEMS_I2C_ADDRESS 0x3A
/* Registers Name ------------------------------------------------------------------------*/
#define LSM303C_ACC_TEMP_L 0x0B
#define LSM303C_ACC_TEMP_H 0x0C
#define LSM303C_ACC_ACT_TSH 0x1E
#define LSM303C_ACC_ACT_DUR 0x1F
#define LSM303C_ACC_WHO_AM_I_REG 0x0F
#define LSM303C_ACC_CTRL1 0x20
#define LSM303C_ACC_CTRL2 0x21
#define LSM303C_ACC_CTRL3 0x22
#define LSM303C_ACC_CTRL4 0x23
#define LSM303C_ACC_CTRL5 0x24
#define LSM303C_ACC_CTRL6 0x25
#define LSM303C_ACC_CTRL7 0x26
#define LSM303C_ACC_STATUS 0x27
#define LSM303C_ACC_OUT_X_L 0x28
#define LSM303C_ACC_OUT_X_H 0x29
#define LSM303C_ACC_OUT_Y_L 0x2A
#define LSM303C_ACC_OUT_Y_H 0x2B
#define LSM303C_ACC_OUT_Z_L 0x2C
#define LSM303C_ACC_OUT_Z_H 0x2D
#define LSM303C_ACC_FIFO_CTRL 0x2E
#define LSM303C_ACC_FIFO_SRC 0x2F
#define LSM303C_ACC_IG_CFG1 0x30
#define LSM303C_ACC_IG_SRC1 0x31
#define LSM303C_ACC_IG_THS_X1 0x32
#define LSM303C_ACC_IG_THS_Y1 0x33
#define LSM303C_ACC_IG_THS_Z1 0x34
#define LSM303C_ACC_IG_DUR1 0x35
#define LSM303C_ACC_IG_CFG2 0x36
#define LSM303C_ACC_IG_SRC2 0x37
#define LSM303C_ACC_IG_THS2 0x38
#define LSM303C_ACC_IG_DUR2 0x39
#define LSM303C_ACC_XL_REFERENCE 0x3A
#define LSM303C_ACC_XH_REFERENCE 0x3B
#define LSM303C_ACC_YL_REFERENCE 0x3C
#define LSM303C_ACC_YH_REFERENCE 0x3D
#define LSM303C_ACC_ZL_REFERENCE 0x3E
#define LSM303C_ACC_ZH_REFERENCE 0x3F
/* Exported macro ------------------------------------------------------------*/
#ifndef __SHARED__MACROS
#define __SHARED__MACROS
#define ValBit(VAR,Place) (VAR & (1<<Place))
#define BIT(x) ( (x) )
#endif
/*__SHARED__MACROS*/
/* Exported constants --------------------------------------------------------*/
#ifndef __SHARED__CONSTANTS
#define __SHARED__CONSTANTS
#define MEMS_SET 0x01
#define MEMS_RESET 0x00
#endif
/*__SHARED__CONSTANTS*/
/* Exported functions --------------------------------------------------------*/
/**********Sensor Configuration Functions***********/
status_t
LSM303C_ACC_SetODR
(
LSM303C_ACC_ODR_t
ov
);
status_t
LSM303C_ACC_SetFullScale
(
LSM303C_ACC_FS_t
ov
);
status_t
LSM303C_ACC_EnableAxis
(
u8_t
ov
);
/***************Filtering Functions****************/
status_t
LSM303C_ACC_HighPassFilterMode
(
LSM303C_ACC_HPM_t
ov
);
status_t
LSM303C_ACC_Select_Bandwidth
(
LSM303C_ACC_BW_t
ov
);
/***************Interrupt Functions****************/
status_t
LSM303C_ACC_EnableInterruptGeneratorOne
(
LSM303C_ACC_IG_CONFIG_t
ov
);
status_t
LSM303C_ACC_EnableInterruptGeneratorTwo
(
LSM303C_ACC_IG_CONFIG_t
ov
);
status_t
LSM303C_ACC_InterruptGeneratorOne_Wait
(
LSM303C_ACC_WAIT_IG_t
ov
);
status_t
LSM303C_ACC_InterruptGeneratorTwo_Wait
(
LSM303C_ACC_WAIT_IG_t
ov
);
status_t
LSM303C_ACC_InterruptGeneratorOne_LogicCondition
(
LSM303C_ACC_AOI_IG_t
ov
);
status_t
LSM303C_ACC_InterruptGeneratorTwo_LogicCondition
(
LSM303C_ACC_AOI_IG_t
ov
);
status_t
LSM303C_ACC_InterruptGeneratorOne_Flag
(
LSM303C_ACC_IG_FLAGS_t
*
value
);
status_t
LSM303C_ACC_InterruptGeneratorTwo_Flag
(
LSM303C_ACC_IG_FLAGS_t
*
value
);
status_t
LSM303C_ACC_IntPin_Mode
(
LSM303C_ACC_INT_PIN_CFG_t
ov
);
status_t
LSM303C_ACC_EnableInterruptPinOne
(
LSM303C_ACC_INT1_DRDY_t
ov
);
status_t
LSM303C_ACC_EnableInterruptPinTwo
(
LSM303C_ACC_INT2_DRDY_t
ov
);
status_t
LSM303C_ACC_InterruptSignalsMode
(
LSM303C_ACC_LAT_SIG_t
ov
);
status_t
LSM303C_ACC_ResetInterruptDuration
(
LSM303C_ACC_RESET_DUR_t
ov
);
status_t
LSM303C_ACC_Status_Flags
(
u8_t
*
value
);
status_t
LSM303C_ACC_SetInterrupt1_Threshold_X
(
u8_t
buff
);
status_t
LSM303C_ACC_SetInterrupt1_Threshold_Y
(
u8_t
buff
);
status_t
LSM303C_ACC_SetInterrupt1_Threshold_Z
(
u8_t
buff
);
status_t
LSM303C_ACC_SetInterrupt2_Threshold_ZYX
(
u8_t
buff
);
status_t
LSM303C_ACC_SetInterrupt1_Duration
(
u8_t
buff
);
status_t
LSM303C_ACC_SetInterrupt2_Duration
(
u8_t
buff
);
status_t
LSM303C_ACC_SetReferenceValue
(
AxesRaw_t
buff
);
status_t
LSM303C_ACC_GetReferenceValue
(
AxesRaw_t
*
buff
);
/*****************FIFO Functions******************/
status_t
LSM303C_ACC_FIFO_Mode
(
LSM303C_ACC_FMODE_t
ov
);
status_t
LSM303C_ACC_FIFO_Flags
(
LSM303C_ACC_FIFO_FLAGS_t
*
value
);
status_t
LSM303C_ACC_FIFO_StopAtTh
(
LSM303C_ACC_STOP_FTH_t
ov
);
status_t
LSM303C_ACC_FIFO
(
LSM303C_ACC_FIFO_EN_t
ov
);
status_t
LSM303C_ACC_SetFIFO_threshold
(
u8_t
buff
);
status_t
LSM303C_ACC_GetFIFO_StoredData
(
u8_t
buff
);
/***************Utility Functions****************/
status_t
LSM303C_ACC_BlockDataUpdate
(
LSM303C_ACC_BDU_t
ov
);
status_t
LSM303C_ACC_SetActivity_Duration
(
u8_t
buff
);
status_t
LSM303C_ACC_SetActivity_Threshold
(
u8_t
buff
);
status_t
LSM303C_ACC_SelfTest
(
LSM303C_ACC_ST_t
ov
);
status_t
LSM303C_ACC_AxOperativeMode
(
LSM303C_ACC_HR_t
ov
);
status_t
LSM303C_ACC_I2C_Mode
(
LSM303C_ACC_I2C_t
ov
);
status_t
LSM303C_ACC_AuotoInc
(
LSM303C_ACC_IF_ADD_INC_t
ov
);
status_t
LSM303C_ACC_SerialInterfaceMode
(
LSM303C_ACC_SIM_t
ov
);
status_t
LSM303C_ACC_DebugMode
(
LSM303C_ACC_DEBUG_t
ov
);
status_t
LSM303C_ACC_SoftReset
(
LSM303C_ACC_SOFT_RESET_t
ov
);
status_t
LSM303C_ACC_Reboot
(
void
);
/****************Reading Functions*****************/
status_t
LSM303C_ACC_GetAccRaw
(
AxesRaw_t
*
buff
);
status_t
LSM303C_ACC_GetTemperatureRaw
(
u16_t
*
buff
);
/*********************Generic*********************/
u8_t
LSM303C_ACC_ReadReg
(
u8_t
Reg
,
u8_t
*
Data
);
u8_t
LSM303C_ACC_WriteReg
(
u8_t
Reg
,
u8_t
Data
);
#endif
/* __LSM303C_ACC_H */
/******************* (C) COPYRIGHT 2013 STMicroelectronics *****END OF FILE****/
sw/common/drivers/LSM303C/LSM303C_MAG_driver.c
deleted
100644 → 0
View file @
abe6c716
/******************** (C) COPYRIGHT 2013 STMicroelectronics ********************
* File Name : LSM303C_MAG.c
* Author : MSH Application Team
* Author : Alberto Zancanato
* Version : ver 1.1
* Date : 09/2013
* Description : LSM303C_MAG driver file
*
* HISTORY:
* Date | Modification | Author
* 08/2012 | Initial Revision | Alberto Zancanato
*
********************************************************************************
* 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 "LSM303C_MAG_driver.h"
#include "lsm303c.h"
//EXAMPLE used to fill LSM303C_MAG_ReadReg and LSM303C_MAG_WriteReg
//#include "i2C_mems.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define LSM303C_MAG_flags_BLE 0x01
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
u8_t
LSM303C_MAG_flags
=
0
;
/* Private function prototypes -----------------------------------------------*/
/*******************************************************************************
* Function Name : LSM303C_MAG_ReadReg
* Description : Generic Reading function. It must be fullfilled with either
* : I2C or SPI reading functions
* Input : Register Address
* Output : Data REad
* Return : None
*******************************************************************************/
u8_t
LSM303C_MAG_ReadReg
(
u8_t
Reg
,
u8_t
*
Data
)
{
return
spi_read
(
DEV_MAG
,
Reg
,
Data
);
}
/*******************************************************************************
* Function Name : LSM303C_MAG_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
*******************************************************************************/
u8_t
LSM303C_MAG_WriteReg
(
u8_t
Reg
,
u8_t
Data
)
{
spi_send
(
DEV_MAG
,
Reg
,
Data
);
return
1
;
}
/* Private functions ---------------------------------------------------------*/
/*******************************************************************************
* Function Name : LSM303C_MAG_SelfTest
* Description : Enable/Disable LSM303C_MAG Self Test
* Input : Self test Enable/Disable [LSM303C_MAG_ST_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_SelfTest
(
LSM303C_MAG_ST_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_CTRL_REG1
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_ST_ENABLE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_CTRL_REG1
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_SetODR
* Description : Sets LSM303C_MAG Output Data Rate
* Input : Set Output data rate [LSM303C_MAG_DO_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_SetODR
(
LSM303C_MAG_DO_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_CTRL_REG1
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_DO_80_Hz
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_CTRL_REG1
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_XY_AxOperativeMode
* Description : Sets LSM303C_MAG Output Data Rate
* Input : Set Output data rate [LSM303C_MAG_OMXY_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_XY_AxOperativeMode
(
LSM303C_MAG_OMXY_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_CTRL_REG1
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_OMXY_ULTRA_HIGH_PERFORMANCE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_CTRL_REG1
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_TemperatureEN
* Description : Enable/Disable LSM303C_MAG Temperature
* Input : Temperature Enable/Disable [LSM303C_MAG_TEMP_EN_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_TemperatureEN
(
LSM303C_MAG_TEMP_EN_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_CTRL_REG1
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_TEMP_EN_ENABLE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_CTRL_REG1
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_SoftReset
* Description : Enable/Disable LSM303C_MAG SoftReset
* Input : SoftReset Enable/Disable [LSM303C_MAG_SOFT_RST_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_SoftReset
(
LSM303C_MAG_SOFT_RST_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_CTRL_REG2
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_SOFT_RST_ENABLE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_CTRL_REG2
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_Reboot
* Description : Enable/Disable LSM303C_MAG Reboot
* Input : Reboot Enable/Disable [LSM303C_MAG_REBOOT_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_Reboot
(
LSM303C_MAG_REBOOT_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_CTRL_REG2
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_REBOOT_YES
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_CTRL_REG2
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_SetFullScale
* Description : set LSM303C_MAG Full scale
* Input : set LSM303C_MAG Full scale [LSM303C_MAG_FS_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_SetFullScale
(
LSM303C_MAG_FS_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_CTRL_REG2
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_FS_16_Ga
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_CTRL_REG2
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_SetMode
* Description : set LSM303C_MAG Mode
* Input : set LSM303C_MAG Mode [LSM303C_MAG_MD_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_SetMode
(
LSM303C_MAG_MD_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_CTRL_REG3
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_MD_POWER_DOWN_2
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_CTRL_REG3
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_SerialInterfaceMode
* Description : set LSM303C_MAG SerialInterfaceMode
* Input : set LSM303C_MAG SerialInterfaceMode [LSM303C_MAG_SIM_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_SerialInterfaceMode
(
LSM303C_MAG_SIM_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_CTRL_REG3
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_SIM_3_WIRE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_CTRL_REG3
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_LowPowerMode
* Description : set LSM303C_MAG LowPowerMode
* Input : set LSM303C_MAG LowPowerMode [LSM303C_MAG_LP_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//#WARNING: If you enable the LP bit you change the ODR and all the axis Operative Mode
status_t
LSM303C_MAG_LowPowerMode
(
LSM303C_MAG_LP_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_CTRL_REG3
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_LP_ENABLE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_CTRL_REG3
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_EndianDataFormat
* Description : set LSM303C_MAG EndianDataFormat
* Input : set LSM303C_MAG EndianDataFormat [LSM303C_MAG_BLE_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
//#WARNING: If you Use this function you have to change the order of the output register
status_t
LSM303C_MAG_EndianDataFormat
(
LSM303C_MAG_BLE_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_CTRL_REG4
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_BLE_MSb_LOW
;
//mask
value
|=
ov
;
if
(
ov
)
LSM303C_MAG_flags
|=
LSM303C_MAG_flags_BLE
;
else
LSM303C_MAG_flags
&=~
LSM303C_MAG_flags_BLE
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_CTRL_REG4
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_Z_AxOperativeMode
* Description : set LSM303C_MAG Z axis operative mode
* Input : set LSM303C_MAG Z axis operative mode [LSM303C_MAG_OMZ_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_Z_AxOperativeMode
(
LSM303C_MAG_OMZ_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_CTRL_REG4
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_OMZ_ULTRA_HIGH_PERFORMANCE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_CTRL_REG4
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_BlockDataUpdate
* Description : Enable/Disable LSM303C_MAG Z BlockDataUpdate
* Input : Enable/Disable LSM303C_MAG Z BlockDataUpdate[LSM303C_MAG_BDU_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_BlockDataUpdate
(
LSM303C_MAG_BDU_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_CTRL_REG5
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_BDU_ENABLE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_CTRL_REG5
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_X_AxDataAvailable
* Description : LSM303C_MAG X Axis data available
* Input : pointer to LSM303C_MAG_XDA_t
* Output : LSM303C_MAG X Axis data available[LSM303C_MAG_XDA_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_X_AxDataAvailable
(
LSM303C_MAG_XDA_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_STATUS_REG
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_XDA_YES
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_Y_AxDataAvailable
* Description : LSM303C_MAG Y Axis data available
* Input : pointer to LSM303C_MAG_YDA_t
* Output : LSM303C_MAG Y Axis data available[LSM303C_MAG_YDA_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_Y_AxDataAvailable
(
LSM303C_MAG_YDA_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_STATUS_REG
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_YDA_YES
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_Z_AxDataAvailable
* Description : LSM303C_MAG Z Axis data available
* Input : pointer to LSM303C_MAG_ZDA_t
* Output : LSM303C_MAG Z Axis data available[LSM303C_MAG_ZDA_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_Z_AxDataAvailable
(
LSM303C_MAG_ZDA_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_STATUS_REG
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_ZDA_YES
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_XYZ_AxDataAvailable
* Description : LSM303C_MAG Axis data available for all axis
* Input : pointer to LSM303C_MAG_XYZDA_t
* Output : LSM303C_MAG XYZ Axis data available[LSM303C_MAG_XYZDA_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_XYZ_AxDataAvailable
(
LSM303C_MAG_XYZDA_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_STATUS_REG
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_XYZDA_YES
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_X_AxisOverrun
* Description : LSM303C_MAG X Data Axis Overrunning
* Input : pointer to LSM303C_MAG_XOR_t
* Output : LSM303C_MAG X Axis data overrun [LSM303C_MAG_XOR_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_X_AxisOverrun
(
LSM303C_MAG_XOR_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_STATUS_REG
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_XOR_YES
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_Y_AxisOverrun
* Description : LSM303C_MAG Y Data Axis Overrunning
* Input : pointer to LSM303C_MAG_YOR_t
* Output : LSM303C_MAG Y Axis data overrun [LSM303C_MAG_YOR_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_Y_AxisOverrun
(
LSM303C_MAG_YOR_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_STATUS_REG
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_YOR_YES
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_Z_AxisOverrun
* Description : LSM303C_MAG Z Data Axis Overrunning
* Input : pointer to LSM303C_MAG_ZOR_t
* Output : LSM303C_MAG Z Axis data overrun [LSM303C_MAG_ZOR_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_Z_AxisOverrun
(
LSM303C_MAG_ZOR_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_STATUS_REG
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_ZOR_YES
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_XYZ_AxisOverrun
* Description : LSM303C_MAG XYZ Data Axis Overrunning
* Input : pointer to LSM303C_MAG_XYZOR_t
* Output : LSM303C_MAG XYZ Axis data overrun [LSM303C_MAG_XYZOR_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_XYZ_AxisOverrun
(
LSM303C_MAG_XYZOR_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_STATUS_REG
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_XYZOR_YES
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_EnableINTpin
* Description : Enable/Disable LSM303C_MAG INT pin
* Input : Enable/Disable LSM303C_MAG INT pin[LSM303C_MAG_IEN_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_EnableINTpin
(
LSM303C_MAG_IEN_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_INT_CFG
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_INTERRUPT_ENABLE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_INT_CFG
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_INTpinLatched
* Description : Enable/Disable LSM303C_MAG INT latched
* Input : Enable/Disable LSM303C_MAG INT latched[LSM303C_MAG_LIR_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_INTpinLatched
(
LSM303C_MAG_LIR_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_INT_CFG
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_LIR_NOT_LATCH
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_INT_CFG
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_INTpinHighLow
* Description : LSM303C_MAG INT active low/high
* Input : LSM303C_MAG INT active low/high[LSM303C_MAG_IEA_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_INTpinHighLow
(
LSM303C_MAG_IEA_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_INT_CFG
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_IEA_HIGH
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_INT_CFG
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_Z_AxINT_Enable
* Description : LSM303C_MAG enable interrupt on Z Axis
* Input : LSM303C_MAG enable interrupt on Z Axis [LSM303C_MAG_ZIEN_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_Z_AxINT_Enable
(
LSM303C_MAG_ZIEN_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_INT_CFG
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_ZIEN_ENABLE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_INT_CFG
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_Y_AxINT_Enable
* Description : LSM303C_MAG enable interrupt on Y Axis
* Input : LSM303C_MAG enable interrupt on Y Axis [LSM303C_MAG_YIEN_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_Y_AxINT_Enable
(
LSM303C_MAG_YIEN_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_INT_CFG
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_YIEN_ENABLE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_INT_CFG
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_X_AxINT_Enable
* Description : LSM303C_MAG enable interrupt on X Axis
* Input : LSM303C_MAG enable interrupt on X Axis [LSM303C_MAG_XIEN_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_X_AxINT_Enable
(
LSM303C_MAG_XIEN_t
ov
){
u8_t
value
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_INT_CFG
,
&
value
)
)
return
MEMS_ERROR
;
value
&=
~
LSM303C_MAG_XIEN_ENABLE
;
//mask
value
|=
ov
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_INT_CFG
,
value
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_InterruptFlag
* Description : LSM303C_MAG Interrupt Flag
* Input : pointer to LSM303C_MAG_INT_t
* Output : LSM303C_MAG Interrupt Flag [LSM303C_MAG_INT_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_InterruptFlag
(
LSM303C_MAG_INT_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_INT_SRC
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_INT_FLAG_UP
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_MeasOverFlow
* Description : LSM303C_MAG measure overflow
* Input : pointer to LSM303C_MAG_MROI_t
* Output : LSM303C_MAG Interrupt Flag [LSM303C_MAG_MROI_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_MeasOverFlow
(
LSM303C_MAG_MROI_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_INT_SRC
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_MROI_OVERFLOW
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_Z_NegativeThresholdFlag
* Description : LSM303C_MAG Z_NegativeThreshold
* Input : pointer to LSM303C_MAG_NTH_Z_t
* Output : LSM303C_MAG Interrupt Flag [LSM303C_MAG_NTH_Z_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_Z_NegativeThresholdFlag
(
LSM303C_MAG_NTH_Z_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_INT_SRC
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_NTH_Z_PASS
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_Y_NegativeThresholdFlag
* Description : LSM303C_MAG Y_NegativeThreshold
* Input : pointer to LSM303C_MAG_NTH_Y_t
* Output : LSM303C_MAG Interrupt Flag [LSM303C_MAG_NTH_Y_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_Y_NegativeThresholdFlag
(
LSM303C_MAG_NTH_Y_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_INT_SRC
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_NTH_Y_PASS
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_X_NegativeThresholdFlag
* Description : LSM303C_MAG X_NegativeThreshold
* Input : pointer to LSM303C_MAG_NTH_X_t
* Output : LSM303C_MAG Interrupt Flag [LSM303C_MAG_NTH_X_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_X_NegativeThresholdFlag
(
LSM303C_MAG_NTH_X_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_INT_SRC
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_NTH_X_PASS
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_Z_PositiveThresholdFlag
* Description : LSM303C_MAG Z Positive threshold
* Input : pointer to LSM303C_MAG_PTH_Z_t
* Output : LSM303C_MAG Interrupt Flag [LSM303C_MAG_PTH_Z_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_Z_PositiveThresholdFlag
(
LSM303C_MAG_PTH_Z_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_INT_SRC
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_PTH_Z_PASS
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_Y_PositiveThresholdFlag
* Description : LSM303C_MAG Y Positive threshold
* Input : pointer to LSM303C_MAG_PTH_Y_t
* Output : LSM303C_MAG Interrupt Flag [LSM303C_MAG_PTH_Y_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_Y_PositiveThresholdFlag
(
LSM303C_MAG_PTH_Y_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_INT_SRC
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_PTH_Y_PASS
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_X_PositiveThresholdFlag
* Description : LSM303C_MAG X Positive threshold
* Input : pointer to LSM303C_MAG_PTH_X_t
* Output : LSM303C_MAG Interrupt Flag [LSM303C_MAG_PTH_X_t]
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_X_PositiveThresholdFlag
(
LSM303C_MAG_PTH_X_t
*
value
){
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_INT_SRC
,
(
u8_t
*
)
value
)
)
return
MEMS_ERROR
;
*
value
&=
LSM303C_MAG_PTH_X_PASS
;
//mask
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_GetMagRaw
* Description : Read magnetic output register
* Input : pointer to AxesRaw_t
* Output : Magnetic Output Registers buffer AxesRaw_t
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_GetMagRaw
(
AxesRaw_t
*
buff
)
{
u8_t
valueL
;
u8_t
valueH
;
if
(
LSM303C_MAG_flags
&
LSM303C_MAG_flags_BLE
)
{
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_OUTX_H
,
&
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_OUTX_L
,
&
valueH
)
)
return
MEMS_ERROR
;
buff
->
AXIS_X
=
(
i16_t
)(
(
valueH
<<
8
)
|
valueL
);
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_OUTY_H
,
&
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_OUTY_L
,
&
valueH
)
)
return
MEMS_ERROR
;
buff
->
AXIS_Y
=
(
i16_t
)(
(
valueH
<<
8
)
|
valueL
);
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_OUTZ_H
,
&
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_OUTZ_L
,
&
valueH
)
)
return
MEMS_ERROR
;
buff
->
AXIS_Z
=
(
i16_t
)(
(
valueH
<<
8
)
|
valueL
);
}
else
{
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_OUTX_L
,
&
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_OUTX_H
,
&
valueH
)
)
return
MEMS_ERROR
;
buff
->
AXIS_X
=
(
i16_t
)(
(
valueH
<<
8
)
|
valueL
);
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_OUTY_L
,
&
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_OUTY_H
,
&
valueH
)
)
return
MEMS_ERROR
;
buff
->
AXIS_Y
=
(
i16_t
)(
(
valueH
<<
8
)
|
valueL
);
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_OUTZ_L
,
&
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_OUTZ_H
,
&
valueH
)
)
return
MEMS_ERROR
;
buff
->
AXIS_Z
=
(
i16_t
)(
(
valueH
<<
8
)
|
valueL
);
}
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_GetTemperatureRaw
* Description : Read Temperature output register
* Input : pointer to u16_t
* Output : Temperature data row to u16_t
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_GetTemperatureRaw
(
u16_t
*
buff
)
{
u8_t
valueL
;
u8_t
valueH
;
if
(
LSM303C_MAG_flags
|
LSM303C_MAG_flags_BLE
)
{
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_TEMP_OUT_H
,
&
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_TEMP_OUT_L
,
&
valueH
)
)
return
MEMS_ERROR
;
*
buff
=
(
i16_t
)(
(
valueH
<<
8
)
|
valueL
);
}
else
{
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_TEMP_OUT_L
,
&
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_MAG_ReadReg
(
LSM303C_MAG_TEMP_OUT_H
,
&
valueH
)
)
return
MEMS_ERROR
;
*
buff
=
(
i16_t
)(
(
valueH
<<
8
)
|
valueL
);
}
return
MEMS_SUCCESS
;
}
/*******************************************************************************
* Function Name : LSM303C_MAG_SetThreshold
* Description : Set Threshold data row
* Input : threshold row value [u16_t]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t
LSM303C_MAG_SetThreshold
(
u16_t
buff
)
{
u8_t
valueL
;
u8_t
valueH
;
valueL
=
buff
&
0x00FF
;
valueH
=
buff
&
0xFF00
>>
8
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_INT_THS_L
,
valueL
)
)
return
MEMS_ERROR
;
if
(
!
LSM303C_MAG_WriteReg
(
LSM303C_MAG_INT_THS_H
,
valueH
)
)
return
MEMS_ERROR
;
return
MEMS_SUCCESS
;
}
sw/common/drivers/LSM303C/LSM303C_MAG_driver.h
deleted
100644 → 0
View file @
abe6c716
/******************** (C) COPYRIGHT 2013 STMicroelectronics ********************
* File Name : LSM303C_MAG_driver.h
* Author : MSH Application Team
* Author : Alberto Zancanato
* Version : ver 1.1
* Date : 09/2013
* Description : Descriptor Header for LSM303C_MAG driver file
*
* HISTORY:
* Date | Modification | Author
* 08/2012 | Initial Revision | Alberto Zancanato
*
********************************************************************************
* 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.
*
*******************************************************************************/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __LSM303C_MAG_DRIVER__H
#define __LSM303C_MAG_DRIVER__H
/* Includes ------------------------------------------------------------------*/
/* Exported types ------------------------------------------------------------*/
//these could change accordingly with the architecture
#ifndef __ARCHDEP__TYPES
#define __ARCHDEP__TYPES
typedef
unsigned
char
u8_t
;
typedef
unsigned
short
int
u16_t
;
typedef
short
int
i16_t
;
typedef
signed
char
i8_t
;
#endif
/*__ARCHDEP__TYPES*/
typedef
u8_t
LSM303C_MAG_Int1PinConf_t
;
typedef
u8_t
LSM303C_MAG_Int2PinConf_t
;
typedef
u8_t
LSM303C_MAG_Int1Conf_t
;
typedef
u8_t
LSM303C_MAG_Axis_t
;
/* Exported common structure --------------------------------------------------------*/
#ifndef __SHARED__TYPES
#define __SHARED__TYPES
typedef
enum
{
MEMS_SUCCESS
=
0x01
,
MEMS_ERROR
=
0x00
}
status_t
;
typedef
enum
{
MEMS_ENABLE
=
0x01
,
MEMS_DISABLE
=
0x00
}
State_t
;
typedef
struct
{
i16_t
AXIS_X
;
i16_t
AXIS_Y
;
i16_t
AXIS_Z
;
}
AxesRaw_t
;
typedef
u8_t
IntPinConf_t
;
typedef
u8_t
Axis_t
;
typedef
u8_t
IntConf_t
;
#endif
/*__SHARED__TYPES*/
typedef
enum
{
LSM303C_MAG_ST_DISABLE
=
0x00
,
LSM303C_MAG_ST_ENABLE
=
0x01
}
LSM303C_MAG_ST_t
;
typedef
enum
{
LSM303C_MAG_DO_0_625_Hz
=
0x00
,
LSM303C_MAG_DO_1_25_Hz
=
0x04
,
LSM303C_MAG_DO_2_5_Hz
=
0x08
,
LSM303C_MAG_DO_5_Hz
=
0x0C
,
LSM303C_MAG_DO_10_Hz
=
0x10
,
LSM303C_MAG_DO_20_hZ
=
0x14
,
LSM303C_MAG_DO_40_Hz
=
0x18
,
LSM303C_MAG_DO_80_Hz
=
0x1C
}
LSM303C_MAG_DO_t
;
typedef
enum
{
LSM303C_MAG_OMXY_LOW_POWER
=
0x00
,
LSM303C_MAG_OMXY_MEDIUM_PERFORMANCE
=
0x20
,
LSM303C_MAG_OMXY_HIGH_PERFORMANCE
=
0x40
,
LSM303C_MAG_OMXY_ULTRA_HIGH_PERFORMANCE
=
0x60
}
LSM303C_MAG_OMXY_t
;
typedef
enum
{
LSM303C_MAG_TEMP_EN_DISABLE
=
0x00
,
LSM303C_MAG_TEMP_EN_ENABLE
=
0x80
}
LSM303C_MAG_TEMP_EN_t
;
typedef
enum
{
LSM303C_MAG_SOFT_RST_DISABLE
=
0x00
,
LSM303C_MAG_SOFT_RST_ENABLE
=
0x04
}
LSM303C_MAG_SOFT_RST_t
;
typedef
enum
{
LSM303C_MAG_REBOOT_NO
=
0x00
,
LSM303C_MAG_REBOOT_YES
=
0x08
}
LSM303C_MAG_REBOOT_t
;
typedef
enum
{
LSM303C_MAG_FS_4_Ga
=
0x00
,
LSM303C_MAG_FS_8_Ga
=
0x20
,
LSM303C_MAG_FS_12_Ga
=
0x40
,
LSM303C_MAG_FS_16_Ga
=
0x60
}
LSM303C_MAG_FS_t
;
typedef
enum
{
LSM303C_MAG_MD_CONTINUOUS
=
0x00
,
LSM303C_MAG_MD_SINGLE
=
0x01
,
LSM303C_MAG_MD_POWER_DOWN_1
=
0x02
,
LSM303C_MAG_MD_POWER_DOWN_2
=
0x03
}
LSM303C_MAG_MD_t
;
typedef
enum
{
LSM303C_MAG_SIM_4_WIRE
=
0x00
,
LSM303C_MAG_SIM_3_WIRE
=
0x04
}
LSM303C_MAG_SIM_t
;
typedef
enum
{
LSM303C_MAG_LP_DISABLE
=
0x00
,
LSM303C_MAG_LP_ENABLE
=
0x20
}
LSM303C_MAG_LP_t
;
typedef
enum
{
LSM303C_MAG_BLE_LSb_LOW
=
0x00
,
LSM303C_MAG_BLE_MSb_LOW
=
0x02
}
LSM303C_MAG_BLE_t
;
typedef
enum
{
LSM303C_MAG_OMZ_LOW_PW
=
0x00
,
LSM303C_MAG_OMZ_MEDIUM_PERFORMANCE
=
0x04
,
LSM303C_MAG_OMZ_HIGH_PERFORMANCE
=
0x08
,
LSM303C_MAG_OMZ_ULTRA_HIGH_PERFORMANCE
=
0x0C
}
LSM303C_MAG_OMZ_t
;
typedef
enum
{
LSM303C_MAG_BDU_DISABLE
=
0x00
,
LSM303C_MAG_BDU_ENABLE
=
0x40
}
LSM303C_MAG_BDU_t
;
typedef
enum
{
LSM303C_MAG_XDA_NO
=
0x00
,
LSM303C_MAG_XDA_YES
=
0x01
}
LSM303C_MAG_XDA_t
;
typedef
enum
{
LSM303C_MAG_YDA_NO
=
0x00
,
LSM303C_MAG_YDA_YES
=
0x02
}
LSM303C_MAG_YDA_t
;
typedef
enum
{
LSM303C_MAG_ZDA_NO
=
0x00
,
LSM303C_MAG_ZDA_YES
=
0x04
}
LSM303C_MAG_ZDA_t
;
typedef
enum
{
LSM303C_MAG_XYZDA_NO
=
0x00
,
LSM303C_MAG_XYZDA_YES
=
0x08
}
LSM303C_MAG_XYZDA_t
;
typedef
enum
{
LSM303C_MAG_XOR_NO
=
0x00
,
LSM303C_MAG_XOR_YES
=
0x10
}
LSM303C_MAG_XOR_t
;
typedef
enum
{
LSM303C_MAG_YOR_NO
=
0x00
,
LSM303C_MAG_YOR_YES
=
0x20
}
LSM303C_MAG_YOR_t
;
typedef
enum
{
LSM303C_MAG_ZOR_NO
=
0x00
,
LSM303C_MAG_ZOR_YES
=
0x40
}
LSM303C_MAG_ZOR_t
;
typedef
enum
{
LSM303C_MAG_XYZOR_NO
=
0x00
,
LSM303C_MAG_XYZOR_YES
=
0x80
}
LSM303C_MAG_XYZOR_t
;
typedef
enum
{
LSM303C_MAG_INTERRUPT_DISABLE
=
0x00
,
LSM303C_MAG_INTERRUPT_ENABLE
=
0x01
}
LSM303C_MAG_IEN_t
;
typedef
enum
{
LSM303C_MAG_LIR_LATCH
=
0x00
,
LSM303C_MAG_LIR_NOT_LATCH
=
0x02
}
LSM303C_MAG_LIR_t
;
typedef
enum
{
LSM303C_MAG_IEA_LOW
=
0x00
,
LSM303C_MAG_IEA_HIGH
=
0x04
}
LSM303C_MAG_IEA_t
;
typedef
enum
{
LSM303C_MAG_ZIEN_DISABLE
=
0x00
,
LSM303C_MAG_ZIEN_ENABLE
=
0x20
}
LSM303C_MAG_ZIEN_t
;
typedef
enum
{
LSM303C_MAG_YIEN_DISABLE
=
0x00
,
LSM303C_MAG_YIEN_ENABLE
=
0x40
}
LSM303C_MAG_YIEN_t
;
typedef
enum
{
LSM303C_MAG_XIEN_DISABLE
=
0x00
,
LSM303C_MAG_XIEN_ENABLE
=
0x80
}
LSM303C_MAG_XIEN_t
;
typedef
enum
{
LSM303C_MAG_INT_FLAG_DOWN
=
0x00
,
LSM303C_MAG_INT_FLAG_UP
=
0x01
}
LSM303C_MAG_INT_t
;
typedef
enum
{
LSM303C_MAG_MROI_NO_OVERFLOW
=
0x00
,
LSM303C_MAG_MROI_OVERFLOW
=
0x02
}
LSM303C_MAG_MROI_t
;
typedef
enum
{
LSM303C_MAG_NTH_Z_NOT_PASS
=
0x00
,
LSM303C_MAG_NTH_Z_PASS
=
0x04
}
LSM303C_MAG_NTH_Z_t
;
typedef
enum
{
LSM303C_MAG_NTH_Y_NOT_PASS
=
0x00
,
LSM303C_MAG_NTH_Y_PASS
=
0x08
}
LSM303C_MAG_NTH_Y_t
;
typedef
enum
{
LSM303C_MAG_NTH_X_NOT_PASS
=
0x00
,
LSM303C_MAG_NTH_X_PASS
=
0x10
}
LSM303C_MAG_NTH_X_t
;
typedef
enum
{
LSM303C_MAG_PTH_Z_NOT_PASS
=
0x00
,
LSM303C_MAG_PTH_Z_PASS
=
0x20
}
LSM303C_MAG_PTH_Z_t
;
typedef
enum
{
LSM303C_MAG_PTH_Y_NOT_PASS
=
0x00
,
LSM303C_MAG_PTH_Y_PASS
=
0x40
}
LSM303C_MAG_PTH_Y_t
;
typedef
enum
{
LSM303C_MAG_PTH_X_NOT_PASS
=
0x00
,
LSM303C_MAG_PTH_X_PASS
=
0x80
}
LSM303C_MAG_PTH_X_t
;
/* Registers Name ------------------------------------------------------------------------*/
#define LSM303C_MAG_WHO_AM__I_ 0x0F
#define LSM303C_MAG_CTRL_REG1 0x20
#define LSM303C_MAG_CTRL_REG2 0x21
#define LSM303C_MAG_CTRL_REG3 0x22
#define LSM303C_MAG_CTRL_REG4 0x23
#define LSM303C_MAG_CTRL_REG5 0x24
#define LSM303C_MAG_STATUS_REG 0x27
#define LSM303C_MAG_OUTX_L 0x28
#define LSM303C_MAG_OUTX_H 0x29
#define LSM303C_MAG_OUTY_L 0x2A
#define LSM303C_MAG_OUTY_H 0x2B
#define LSM303C_MAG_OUTZ_L 0x2C
#define LSM303C_MAG_OUTZ_H 0x2D
#define LSM303C_MAG_TEMP_OUT_L 0x2E
#define LSM303C_MAG_TEMP_OUT_H 0x2F
#define LSM303C_MAG_INT_CFG 0x30
#define LSM303C_MAG_INT_SRC 0x31
#define LSM303C_MAG_INT_THS_L 0x32
#define LSM303C_MAG_INT_THS_H 0x33
/* Exported macro ------------------------------------------------------------*/
#ifndef __SHARED__MACROS
#define __SHARED__MACROS
#define ValBit(VAR,Place) (VAR & (1<<Place))
#define BIT(x) ( (x) )
#endif
/*__SHARED__MACROS*/
/* Exported constants --------------------------------------------------------*/
#ifndef __SHARED__CONSTANTS
#define __SHARED__CONSTANTS
#define MEMS_SET 0x01
#define MEMS_RESET 0x00
#endif
/*__SHARED__CONSTANTS*/
/************** I2C Address *****************/
#define LSM303C_MAG_MEMS_I2C_ADDRESS 0x3C
/* Exported functions --------------------------------------------------------*/
/**********Sensor Configuration Functions***********/
status_t
LSM303C_MAG_SetODR
(
LSM303C_MAG_DO_t
ov
);
status_t
LSM303C_MAG_SetFullScale
(
LSM303C_MAG_FS_t
ov
);
status_t
LSM303C_MAG_SetMode
(
LSM303C_MAG_MD_t
ov
);
status_t
LSM303C_MAG_BlockDataUpdate
(
LSM303C_MAG_BDU_t
ov
);
status_t
LSM303C_MAG_TemperatureEN
(
LSM303C_MAG_TEMP_EN_t
ov
);
status_t
LSM303C_MAG_XY_AxOperativeMode
(
LSM303C_MAG_OMXY_t
ov
);
status_t
LSM303C_MAG_Z_AxOperativeMode
(
LSM303C_MAG_OMZ_t
ov
);
/***************Interrupt Functions****************/
status_t
LSM303C_MAG_EnableINTpin
(
LSM303C_MAG_IEN_t
ov
);
status_t
LSM303C_MAG_INTpinLatched
(
LSM303C_MAG_LIR_t
ov
);
status_t
LSM303C_MAG_INTpinHighLow
(
LSM303C_MAG_IEA_t
ov
);
status_t
LSM303C_MAG_Z_AxINT_Enable
(
LSM303C_MAG_ZIEN_t
ov
);
status_t
LSM303C_MAG_Y_AxINT_Enable
(
LSM303C_MAG_YIEN_t
ov
);
status_t
LSM303C_MAG_X_AxINT_Enable
(
LSM303C_MAG_XIEN_t
ov
);
status_t
LSM303C_MAG_InterruptFlag
(
LSM303C_MAG_INT_t
*
value
);
status_t
LSM303C_MAG_Z_NegativeThresholdFlag
(
LSM303C_MAG_NTH_Z_t
*
value
);
status_t
LSM303C_MAG_Y_NegativeThresholdFlag
(
LSM303C_MAG_NTH_Y_t
*
value
);
status_t
LSM303C_MAG_X_NegativeThresholdFlag
(
LSM303C_MAG_NTH_X_t
*
value
);
status_t
LSM303C_MAG_Z_PositiveThresholdFlag
(
LSM303C_MAG_PTH_Z_t
*
value
);
status_t
LSM303C_MAG_Y_PositiveThresholdFlag
(
LSM303C_MAG_PTH_Y_t
*
value
);
status_t
LSM303C_MAG_X_PositiveThresholdFlag
(
LSM303C_MAG_PTH_X_t
*
value
);
status_t
LSM303C_MAG_SetThreshold
(
u16_t
buff
);
status_t
LSM303C_MAG_X_AxDataAvailable
(
LSM303C_MAG_XDA_t
*
value
);
status_t
LSM303C_MAG_Y_AxDataAvailable
(
LSM303C_MAG_YDA_t
*
value
);
status_t
LSM303C_MAG_Z_AxDataAvailable
(
LSM303C_MAG_ZDA_t
*
value
);
status_t
LSM303C_MAG_XYZ_AxDataAvailable
(
LSM303C_MAG_XYZDA_t
*
value
);
status_t
LSM303C_MAG_X_AxisOverrun
(
LSM303C_MAG_XOR_t
*
value
);
status_t
LSM303C_MAG_Y_AxisOverrun
(
LSM303C_MAG_YOR_t
*
value
);
status_t
LSM303C_MAG_Z_AxisOverrun
(
LSM303C_MAG_ZOR_t
*
value
);
status_t
LSM303C_MAG_Z_AxisOverrun
(
LSM303C_MAG_ZOR_t
*
value
);
status_t
LSM303C_MAG_XYZ_AxisOverrun
(
LSM303C_MAG_XYZOR_t
*
value
);
status_t
LSM303C_MAG_MeasOverFlow
(
LSM303C_MAG_MROI_t
*
value
);
/***************Utility Functions****************/
status_t
LSM303C_MAG_SoftReset
(
LSM303C_MAG_SOFT_RST_t
ov
);
status_t
LSM303C_MAG_Reboot
(
LSM303C_MAG_REBOOT_t
ov
);
status_t
LSM303C_MAG_SelfTest
(
LSM303C_MAG_ST_t
ov
);
status_t
LSM303C_MAG_LowPowerMode
(
LSM303C_MAG_LP_t
ov
);
status_t
LSM303C_MAG_EndianDataFormat
(
LSM303C_MAG_BLE_t
ov
);
status_t
LSM303C_MAG_SerialInterfaceMode
(
LSM303C_MAG_SIM_t
ov
);
/****************Reading Functions*****************/
status_t
LSM303C_MAG_GetMagRaw
(
AxesRaw_t
*
buff
);
status_t
LSM303C_MAG_GetTemperatureRaw
(
u16_t
*
buff
);
/*********************Generic*********************/
u8_t
LSM303C_MAG_ReadReg
(
u8_t
Reg
,
u8_t
*
Data
);
u8_t
LSM303C_MAG_WriteReg
(
u8_t
Reg
,
u8_t
Data
);
#endif
/* __LSM303C_MAG_H */
/******************* (C) COPYRIGHT 2013 STMicroelectronics *****END OF FILE****/
sw/common/drivers/LSM303C/cpu_calls2.c
deleted
100644 → 0
View file @
abe6c716
#include <em_cmu.h>
//#include <em_device.h>
#include <em_gpio.h>
#include <em_usart.h>
//#include <efm32gg_usart.h>
#include <efm32gg330f1024.h>
#include "cpu_calls.h"
#include "LSM303C_ACC_driver.h"
#include "LSM303C_MAG_driver.h"
#define HFRCO_FREQUENCY 14000000
#define SPI_PERCLK_FREQUENCY HFRCO_FREQUENCY
#define SPI_BAUDRATE 1000000
#define SPI_LOC USART_ROUTE_LOCATION_LOC2 //2
#define BUFSIZE 80
#define SPI_USART USART0
#define ACC_CS_PIN 8
#define MAG_CS_PIN 10
char
spi_txbuf
[
BUFSIZE
];
char
spi_rxbuf
[
BUFSIZE
];
volatile
int
spi_txbuf_idx
;
/* index of spi_txbuf, used by Tx irq handler, must
* be initialized to 0 before tx data written to buffer */
volatile
int
spi_rxbuf_idx
;
/* index of spi_rxbuf, used by Rx irq handler, must
* be initialized to 0 before expected data reception */
int
txbuf_sz
;
// Based on
// http://community.silabs.com/t5/tkb/articleprintpage/tkb-id/1000/article-id/1985
/*TODO: move away from here*/
int
temp_lsm303_init
()
{
uint8_t
dat
=
0
;
AxesRaw_t
meas
;
spi_init
();
//LSM303C_ACC_Reboot();
/*setup 3-wire SPI for Accelerometer & Magnetometer*/
LSM303C_ACC_SerialInterfaceMode
(
LSM303C_ACC_SIM_3WIRE_INTERFACE
);
// LSM303C_MAG_SerialInterfaceMode(LSM303C_MAG_SIM_3_WIRE);
LSM303C_ACC_ReadReg
(
LSM303C_ACC_WHO_AM_I_REG
,
&
dat
);
/* read WHO_AM_I_A */
/*ACC self test*/
//LSM303C_ACC_SelfTest(LSM303C_ACC_ST_POSITIVE);
return
dat
;
}
int
spi_init
()
{
USART_InitSync_TypeDef
cfg
=
USART_INITSYNC_DEFAULT
;
USART_TypeDef
*
spi
=
SPI_USART
;
//CHIP_Init();
/*Enable clock to USART0 and GPIO*/
CMU_ClockEnable
(
cmuClock_USART0
,
true
);
/* basic configuration */
cfg
.
baudrate
=
SPI_BAUDRATE
;
cfg
.
clockMode
=
usartClockMode3
;
//Clock idle high, sample on rising edge
cfg
.
msbf
=
true
;
//MSB first
USART_InitSync
(
SPI_USART
,
&
cfg
);
/* signals routing to location 2 and loopback for half-duplex */
spi
->
CTRL
|=
USART_CTRL_LOOPBK
;
/* use half-duplex */
spi
->
ROUTE
=
USART_ROUTE_CLKPEN
|
USART_ROUTE_TXPEN
|
// USART_ROUTE_CSPEN /* don't know yet about CS, I'll try to drive it 'by hand' */
SPI_LOC
;
CMU_ClockEnable
(
cmuClock_GPIO
,
true
);
/* GPIO configuration */
GPIO_PinModeSet
(
gpioPortC
,
11
,
gpioModePushPull
,
0
);
/* MOSI/MISO */
GPIO_PinModeSet
(
gpioPortC
,
MAG_CS_PIN
,
gpioModePushPull
,
1
);
/* CS Mag*/
GPIO_PinModeSet
(
gpioPortC
,
ACC_CS_PIN
,
gpioModePushPull
,
1
);
/* CS Acc*/
GPIO_PinModeSet
(
gpioPortC
,
9
,
gpioModePushPull
,
1
);
/* Clock */
GPIO_PinModeSet
(
gpioPortD
,
4
,
gpioModeInput
,
0
);
/* Mag drdy */
/* buffers init */
spi_txbuf_idx
=
0
;
spi_rxbuf_idx
=
0
;
/* finally enable USART (Tx & RX)*/
//USART_Enable(spi, usartEnable);
/*setup Rx irq*/
//spi->CMD = USART_CMD_CLEARRX;
//NVIC_ClearPendingIRQ(USART0_RX_IRQn);
//NVIC_EnableIRQ(USART0_RX_IRQn);
//spi->IEN |= USART_IEN_RXDATAV;
/*setup Tx irq*/
//spi->CMD = USART_CMD_CLEARTX;
//NVIC_ClearPendingIRQ(USART0_TX_IRQn);
//NVIC_EnableIRQ(USART0_TX_IRQn);
//spi->IEN |= USART_IEN_TXBL;
return
0
;
}
void
spi_send
(
uint8_t
dev
,
uint8_t
adr
,
uint8_t
dat
)
{
USART_TypeDef
*
spi
=
SPI_USART
;
if
(
dev
==
DEV_ACC
)
{
/* drive ACC CS down */
GPIO_PinOutClear
(
gpioPortC
,
ACC_CS_PIN
);
GPIO_PinOutSet
(
gpioPortC
,
MAG_CS_PIN
);
}
else
if
(
dev
==
DEV_MAG
)
{
/* drive MAG CS down */
GPIO_PinOutSet
(
gpioPortC
,
ACC_CS_PIN
);
GPIO_PinOutClear
(
gpioPortC
,
MAG_CS_PIN
);
}
//spi->TXDOUBLE = adr << _USART_TXDOUBLE_TXDATA0_SHIFT |
// dat << _USART_TXDOUBLE_TXDATA1_SHIFT;
USART_TxDouble
(
spi
,
adr
<<
_USART_TXDOUBLE_TXDATA0_SHIFT
|
dat
<<
_USART_TXDOUBLE_TXDATA1_SHIFT
);
/* wait until it's done */
while
(
!
(
USART_StatusGet
(
spi
)
&
USART_STATUS_TXC
))
;
/* both CS up */
GPIO_PinOutSet
(
gpioPortC
,
ACC_CS_PIN
);
GPIO_PinOutSet
(
gpioPortC
,
MAG_CS_PIN
);
}
/* read byte from given address */
uint8_t
spi_read
(
uint8_t
dev
,
uint8_t
adr
)
{
USART_TypeDef
*
spi
=
SPI_USART
;
if
(
dev
==
DEV_ACC
)
{
/* drive ACC CS down */
GPIO_PinOutClear
(
gpioPortC
,
ACC_CS_PIN
);
GPIO_PinOutSet
(
gpioPortC
,
MAG_CS_PIN
);
}
else
if
(
dev
==
DEV_MAG
)
{
/* drive MAG CS down */
GPIO_PinOutSet
(
gpioPortC
,
ACC_CS_PIN
);
GPIO_PinOutClear
(
gpioPortC
,
MAG_CS_PIN
);
}
spi
->
CMD
=
USART_CMD_RXBLOCKEN
;
/* Block loopbacked RX while we send adr to Slave */
spi
->
CMD
=
USART_CMD_CLEARRX
;
/* Clear old data, if any */
spi
->
TXDOUBLEX
=
(
adr
|
1
<<
7
)
<<
_USART_TXDOUBLEX_TXDATA0_SHIFT
|
USART_TXDOUBLEX_TXTRIAT0
|
/* tristate Tx */
USART_TXDOUBLEX_UBRXAT0
|
/* unblock Rx */
0x00
<<
_USART_TXDOUBLEX_TXDATA1_SHIFT
|
/* dummy Tx data for reading Slave */
USART_TXDOUBLEX_TXTRIAT1
|
/* once again, errata USART_E101 */
USART_TXDOUBLEX_UBRXAT1
;
/* wait for valid rx data */
while
(
!
(
USART_StatusGet
(
spi
)
&
USART_STATUS_RXDATAV
)
);
/* we have new data, turn off tristate Tx */
spi
->
CMD
=
USART_CMD_TXTRIDIS
;
/* both CS up */
GPIO_PinOutSet
(
gpioPortC
,
ACC_CS_PIN
);
GPIO_PinOutSet
(
gpioPortC
,
MAG_CS_PIN
);
return
spi
->
RXDATA
&
0xff
;
}
//void spi_send(char* buf, int size)
//{
// USART_TypeDef *spi = SPI_USART;
// int i;
//
// for (i = 0; i<size; i++) {
// /* Waiting for the usart to be ready */
// while (!(uart->STATUS & USART_STATUS_TXBL)) ;
//
// if (buf) {
// /* Writing next byte to USART */
// uart->TXDATA = *buf;
// buf++;
// }
// else
// uart->TXDATA = 0;
// }
//
// /*Waiting for transmission of last byte */
// while (!(uart->STATUS & USART_STATUS_TXC)) ;
//}
/* Rx IRQ handler, receives byte from SPI, and writes to next position in
* the rxbuf */
//void spi_rx_irq()
//{
// USART_TypeDef *spi = SPI_USART;
//
// if (spi->STATUS & USART_STATUS_RXDATAV) {
// /*we have valid data received from SPI*/
// if (spi_rxbuf_idx < BUFSIZE)
// spi_rxbuf[spi_rxbuf_idx++] = spi->RXDATA;
// }
//}
/* Tx IRQ handler, sends txbuf byte by byte for a given rxbuf_sz, using
* spi_txbuf_idx to mark subsequent bytes between calls */
//void spi_tx_irq()
//{
// USART_TypeDef *spi = SPI_USART;
//
// if (spi->STATUS & USART_STATUS_TXBL) {
// if (spi_txbuf_idx < txbuf_sz)
// /* there is next byte in the buffer to be sent */
// spi->TXDATA = spi_txbuf_idx[spi_txbuf_idx++];
// else
// spi->TXDATA = 0;
// }
//}
//void spi_setup(uint8_t spiNumber, uint8_t location)
//{
// USART_TypeDef *spi;
//
// /* Determining USART */
// switch (spiNumber)
// {
// case 0:
// spi = USART0;
// break;
// case 1:
// spi = USART1;
// break;
// case 2:
// spi = USART2;
// break;
// default:
// return;
// }
//
// /* Setting baudrate */
// //spi->CLKDIV = 128 * (SPI_PERCLK_FREQUENCY / SPI_BAUDRATE - 2);
//
// /* Configure SPI */
// spi->CTRL = USART_CTRL_SYNC | /* synchronous (SPI) mode */
// USART_CTRL_LOOPBK; /* use half-duplex */
// /* Clearing old transfers/receptions, and disabling interrupts */
// spi->CMD = USART_CMD_CLEARRX | USART_CMD_CLEARTX;
// spi->IEN = 0;
// /* Enabling pins and setting location */
// spi->ROUTE = USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_CLKPEN | USART_ROUTE_CSPEN | (location << 8);
//
// /* Enabling Master, TX and RX */
// spi->CMD = USART_CMD_MASTEREN | USART_CMD_TXEN | USART_CMD_RXEN;
// //spi->CTRL |= USART_CTRL_AUTOCS; /* sorry, no AUTOCS, because ACC and MAG
// /* have separete CS signals and we have
// * to choose witch whom to speak */
//
// /* Clear previous interrupts */
// spi->IFC = _USART_IFC_MASK;
//
// /* fuck the rest of the USARTs and locations, our case is simple, USART0 & Loc 2 */
// GPIO_PinModeSet(gpioPortC, 11, gpioModePushPull, 0); /* MOSI/MISO */
// GPIO_PinModeSet(gpioPortC, 10, gpioModePushPull, 1); /* CS Mag*/
// GPIO_PinModeSet(gpioPortC, 8, gpioModePushPull, 1); /* CS Acc*/
// GPIO_PinModeSet(gpioPortC, 9, gpioModePushPull, 1); /* Clock */
// GPIO_PinModeSet(gpioPortD, 4, gpioModeInput, 0); /* Mag drdy */
//
//}
sw/common/pp_printf/pp-printf.h
deleted
100644 → 0
View file @
abe6c716
#include <stdarg.h>
extern
int
pp_sprintf
(
char
*
s
,
const
char
*
fmt
,
...)
__attribute__
((
format
(
printf
,
2
,
3
)));
extern
int
pp_vsprintf
(
char
*
buf
,
const
char
*
,
va_list
)
__attribute__
((
format
(
printf
,
2
,
0
)));
sw/common/pp_printf/vsprintf-xint.c
deleted
100644 → 0
View file @
abe6c716
/*
* vsprintf-xint: a possible free-software replacement for mprintf
*
* public domain
*/
#include <stdarg.h>
#include <stdint.h>
static
const
char
hex
[]
=
"0123456789abcdef"
;
static
int
number
(
char
*
out
,
unsigned
value
,
int
base
,
int
lead
,
int
wid
)
{
char
tmp
[
16
];
int
i
=
16
,
ret
,
negative
=
0
;
/* No error checking at all: it is as ugly as possible */
if
((
signed
)
value
<
0
&&
base
==
10
)
{
negative
=
1
;
value
=
-
value
;
}
while
(
value
&&
i
)
{
tmp
[
--
i
]
=
hex
[
value
%
base
];
value
/=
base
;
}
if
(
i
==
16
)
tmp
[
--
i
]
=
'0'
;
if
(
negative
&&
lead
==
' '
)
{
tmp
[
--
i
]
=
'-'
;
negative
=
0
;
}
while
(
i
>
16
-
wid
+
negative
)
tmp
[
--
i
]
=
lead
;
if
(
negative
)
tmp
[
--
i
]
=
'-'
;
ret
=
16
-
i
;
while
(
i
<
16
)
*
(
out
++
)
=
tmp
[
i
++
];
return
ret
;
}
int
pp_vsprintf
(
char
*
buf
,
const
char
*
fmt
,
va_list
args
)
{
char
*
s
,
*
str
=
buf
;
int
base
,
lead
,
wid
;
for
(;
*
fmt
;
++
fmt
)
{
if
(
*
fmt
!=
'%'
)
{
*
str
++
=
*
fmt
;
continue
;
}
base
=
10
;
lead
=
' '
;
wid
=
1
;
repeat:
fmt
++
;
/* Skip '%' initially, other stuff later */
switch
(
*
fmt
)
{
case
'\0'
:
goto
ret
;
case
'0'
:
lead
=
'0'
;
goto
repeat
;
case
'*'
:
/* should be precision, just eat it */
base
=
va_arg
(
args
,
int
);
/* fall through: discard unknown stuff */
default:
if
(
*
fmt
>=
'1'
&&
*
fmt
<=
'9'
)
wid
=
*
fmt
-
'0'
;
goto
repeat
;
/* Special cases for conversions */
case
'c'
:
/* char: supported */
*
str
++
=
(
unsigned
char
)
va_arg
(
args
,
int
);
break
;
case
's'
:
/* string: supported */
s
=
va_arg
(
args
,
char
*
);
while
(
*
s
)
*
str
++
=
*
s
++
;
break
;
case
'n'
:
/* number-thus-far: not supported */
break
;
case
'%'
:
/* supported */
*
str
++
=
'%'
;
break
;
/* integers are more or less printed */
case
'p'
:
case
'x'
:
case
'X'
:
base
=
16
;
case
'o'
:
if
(
base
==
10
)
/* yet unchaged */
base
=
8
;
case
'd'
:
case
'i'
:
case
'u'
:
str
+=
number
(
str
,
va_arg
(
args
,
int
),
base
,
lead
,
wid
);
break
;
}
}
ret:
*
str
=
'\0'
;
return
str
-
buf
;
}
int
pp_sprintf
(
char
*
s
,
const
char
*
fmt
,
...)
{
va_list
args
;
int
ret
;
va_start
(
args
,
fmt
);
ret
=
pp_vsprintf
(
s
,
fmt
,
args
);
va_end
(
args
);
return
ret
;
}
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment