Commit 0b340388 authored by Projects's avatar Projects

Removed unused files.

parent 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;
}
/******************** (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****/
/******************** (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;
}
/******************** (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****/
#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 */
//
//}
#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)));
/*
* 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;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment