/**
* @brief This function handles TIM4 global interrupt request.
* @param None
* @retval None
*/
void TIM4_IRQHandler(void)
{
#if 0
uint8_t clickreg = 0;
if (AudioPlayStart != 0x00)
{
/* Read click status register */
LIS302DL_Read(&clickreg, LIS302DL_CLICK_SRC_REG_ADDR, 1);
LIS302DL_Read(Buffer, LIS302DL_STATUS_REG_ADDR, 6);
}
/* Checks whether the TIM interrupt has occurred */
if (TIM_GetITStatus(TIM4, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM4, TIM_IT_CC1);
if( LED_Toggle == 3)
{
/* LED3 Orange toggling */
STM_EVAL_LEDToggle(LED3);
STM_EVAL_LEDOff(LED6);
STM_EVAL_LEDOff(LED4);
}
else if( LED_Toggle == 4)
{
/* LED4 Green toggling */
STM_EVAL_LEDToggle(LED4);
STM_EVAL_LEDOff(LED6);
STM_EVAL_LEDOff(LED3);
}
else if( LED_Toggle == 6)
{
/* LED6 Blue toggling */
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
STM_EVAL_LEDToggle(LED6);
}
else if (LED_Toggle ==0)
{
/* LED6 Blue On to signal Pause */
STM_EVAL_LEDOn(LED6);
}
else if (LED_Toggle == 7)
{
/* LED4 toggling with frequency = 439.4 Hz */
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
STM_EVAL_LEDOff(LED5);
STM_EVAL_LEDOff(LED6);
}
capture = TIM_GetCapture1(TIM4);
TIM_SetCompare1(TIM4, capture + CCR_Val);
}
#endif
}
/**
* @brief Reads data from the accelerometer and returns an accel_data.
*
* @note Reads data from the accelerometer and returns three signed
* integers contained within an accel_data packet. It starts
* reading at address 0x29, which corresponds to Out_X, and
* reads the next five registers that represent the three axes.
* The results must be casted to a signed integer, and then
* multiplied by 18 as each LSB represents 18mgs.
*
* @return the pitch and roll in degrees.
*/
angle_data read_Accelerometer(void){
uint8_t Buffer[5];
accel_data returned_vals;
angle_data angle_vals;
//0x29 is the first register for Out_X. Followed
//by Out_Y and Out_Z, each separated by a "junk" register.
LIS302DL_Read(Buffer, 0x29, 5);
returned_vals.x = (int8_t)(Buffer[0]) * 18;
returned_vals.y = (int8_t)(Buffer[2]) * 18;
returned_vals.z = (int8_t)(Buffer[4]) * 18;
returned_vals.x += 8.1;
returned_vals.y += 29.3;
returned_vals.z += -10.2;
returned_vals.x = filter_Value(&Filter_Structure_X, returned_vals.x);
returned_vals.y = filter_Value(&Filter_Structure_Y, returned_vals.y);
returned_vals.z = filter_Value(&Filter_Structure_Z, returned_vals.z);
angle_vals.pitch = (atan(returned_vals.x/sqrt(pow(returned_vals.y,2) + pow(returned_vals.z, 2))))*(180/3.14);
angle_vals.roll = (atan(returned_vals.y/sqrt(pow(returned_vals.x,2) + pow(returned_vals.z, 2))))*(180/3.14);
return angle_vals;
}
/**
* @brief handles when the external interrupt happens
*/
void EXTI0_IRQHandler () {
tick = 1;
uint8_t crtl;
LIS302DL_Read(&crtl, LIS302DL_CLICK_SRC_REG_ADDR , 1);
EXTI_ClearFlag(LIS302DL_SPI_INT1_EXTI_LINE);//reset the interrupt flag
}
/**
* @brief This function handles TIM4 global interrupt request.
* @param None
* @retval None
*/
void TIM4_IRQHandler(void)
{
static __IO uint8_t servo1TurningRight = 1;
static __IO uint8_t servo2TurningRight = 1;
int16_t incrementX = 0;
int16_t incrementY = 0;
/* TIM_Update */
if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
{
TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
/* Read MEMS values */
Buffer[0] = 0;
Buffer[2] = 0;
LIS302DL_Read(Buffer, LIS302DL_OUT_X_ADDR, 4);
/* Remove the offsets values from data */
Buffer[0] -= XOffset;
Buffer[2] -= YOffset;
incrementX = Buffer[0] * LIS302DL_SENSITIVITY_2_3G;
servo1Pulse = incrementX + 1500;
incrementY = Buffer[2] * LIS302DL_SENSITIVITY_2_3G;
servo2Pulse = incrementY + 1500;
TIM_SetCompare1(TIM4, servo1Pulse);
TIM_SetCompare2(TIM4, servo1Pulse);
TIM_SetCompare3(TIM4, servo2Pulse);
TIM_SetCompare4(TIM4, servo2Pulse);
}
}
int main(void) {
unsigned char welcome_str[] = "xxyyzz\r\n";
u8 loop = 1;
initPA15();
init_USART1(BT_BAUD);
init_LIS302DL();
// setPA15On();
// togglePA15();
while(loop){
//Read and print the accelerometer values
LIS302DL_Read(Buffer, LIS302DL_OUT_X_ADDR, 6);
printf("%d, %d ,%d\n",Buffer[0],Buffer[2],Buffer[4]);
//Send data through the bluetooth communication
UARTSend(welcome_str, sizeof(welcome_str));
//Wait some time befor ending the loop
Delay(10000000);
}
/* Disable SPI1 used to drive the MEMS accelerometre */
SPI_Cmd(LIS302DL_SPI, DISABLE);
/* Disable the UART connection */
USART_Cmd(USART1, DISABLE);
}
void LIS302DL_Reboot(SPI_TypeDef* spi) {
uint8_t tmpreg;
// Read the CTRL_REG2, enable the reboot memory flag and write it back
LIS302DL_Read(spi, &tmpreg, LIS302DL_CTRL_REG2_ADDR, 1);
tmpreg |= (uint8_t)LIS302DL_BIT1;
LIS302DL_Write(spi, &tmpreg, LIS302DL_CTRL_REG2_ADDR, 1);
}
void LIS302DL_ReadACCY(int32_t* out) {
u8 buffer[6];
LIS302DL_Read(0x2B, buffer, 6);
for(int i=0; i<3; i++) {
*out =(int32_t)(72 * (int8_t)buffer[2*i]);
out++;
}
}
void acceleration_task() {
vTaskDelay(60);
uint8_t buffer[6];
LIS302DL_Read(buffer, LIS302DL_OUT_X_ADDR, 6);
for (;;) {
signed char result;
xQueueReceive(queue, &result, portMAX_DELAY);
display_bar(-128, 128, result);
}
}
void LIS302DL_GetGlobalInterruptConfiguration(SPI_TypeDef* spi, LIS302DL_GlobalInterruptConfig* pConfig) {
uint8_t cnf = 0x00;
LIS302DL_Read(&cnf, LIS302DL_CTRL_REG2_ADDR, 1);
// Map received data into the configuration; Data is delivered in BigEndian
pConfig->SendData = cnf & (uint8_t)LIS302DL_BIT3 ? 0x01 : 0x00;
pConfig->Interrupt_1 = cnf & (uint8_t)LIS302DL_BIT4 ? 0x01 : 0x00;
pConfig->Interrupt_2 = cnf & (uint8_t)LIS302DL_BIT5 ? 0x01 : 0x00;
pConfig->CutOffFrequency = cnf & (uint8_t)~(LIS302DL_BIT0 | LIS302DL_BIT1 | LIS302DL_BIT2 | LIS302DL_BIT3 | LIS302DL_BIT4 | LIS302DL_BIT5);
}
void LIS302D_ChangePowerControl(SPI_TypeDef* spi, bool enableActiveMode) {
uint8_t tmpreg;
// Read the CTRL_REG1, enable/disable the PD memory flag and write it back
LIS302DL_Read(spi, &tmpreg, LIS302DL_CTRL_REG1_ADDR, 1);
tmpreg &= (uint8_t)~LIS302DL_BIT1; // Unset the FS bit
if (enableActiveMode) { // If the bit is set, we are in active mode, else in power down control
tmpreg |= (uint8_t)LIS302DL_BIT1;
}
LIS302DL_Write(spi, &tmpreg, LIS302DL_CTRL_REG1_ADDR, 1);
}
void LIS302D_ChangeDataRate(SPI_TypeDef* spi, bool enableHighSpeed) {
uint8_t tmpreg;
// Read the CTRL_REG1, enable/disable the DR memory flag and write it back
LIS302DL_Read(spi, &tmpreg, LIS302DL_CTRL_REG1_ADDR, 1);
tmpreg &= (uint8_t)~LIS302DL_BIT0; // Unset the FS bit
if (!enableHighSpeed) { // If the bit is set, we are on 400Hz, otherwise on 100Hz
tmpreg |= (uint8_t)LIS302DL_BIT0;
}
LIS302DL_Write(spi, &tmpreg, LIS302DL_CTRL_REG1_ADDR, 1);
}
void LIS302DL_ChangeScaleMode(SPI_TypeDef* spi, bool fullScaleEnable) {
uint8_t tmpreg;
// Read the CTRL_REG1, enable/disable the FS memory flag and write it back
LIS302DL_Read(spi, &tmpreg, LIS302DL_CTRL_REG1_ADDR, 1);
tmpreg &= (uint8_t)~LIS302DL_BIT2; // Unset the FS bit
if (!fullScaleEnable) { // If the bit is not set, we are in ±2.3g mode (full scale)
tmpreg |= (uint8_t)LIS302DL_BIT2;
}
LIS302DL_Write(spi, &tmpreg, LIS302DL_CTRL_REG1_ADDR, 1);
}
int main(void) {
init();
u8 id;
LIS302DL_Read(0x0F, &id, 1);
while(1) {
loop();
}
}
/**
* @brief Reboot memory content of LIS302DL
* @param None
* @retval None
*/
void LIS302DL_RebootCmd(void) {
uint8_t tmpreg;
/* Read CTRL_REG2 register */
LIS302DL_Read(&tmpreg, LIS302DL_CTRL_REG2_ADDR, 1);
/* Enable or Disable the reboot memory */
tmpreg |= LIS302DL_BOOT_REBOOTMEMORY;
/* Write value to MEMS CTRL_REG2 regsister */
LIS302DL_Write(&tmpreg, LIS302DL_CTRL_REG2_ADDR, 1);
}
void LIS302DL_InterruptConfig(LIS302DL_InterruptConfigTypeDef *LIS302DL_IntConfigStruct)
{
uint8_t ctrl = 0x00;
/* Read CLICK_CFG register */
LIS302DL_Read(&ctrl, LIS302DL_CLICK_CFG_REG_ADDR, 1);
/* Configure latch Interrupt request, click interrupts and double click interrupts */
ctrl = (uint8_t)(LIS302DL_IntConfigStruct->Latch_Request| \
LIS302DL_IntConfigStruct->SingleClick_Axes | \
LIS302DL_IntConfigStruct->DoubleClick_Axes);
/* Write value to MEMS CLICK_CFG register */
LIS302DL_Write(&ctrl, LIS302DL_CLICK_CFG_REG_ADDR, 1);
}
/**
* @brief Data Rate command
* @param DataRateValue: Data rate value
* This parameter can be one of the following values:
* @arg LIS302DL_DATARATE_100: 100 Hz output data rate
* @arg LIS302DL_DATARATE_400: 400 Hz output data rate
* @retval None
*/
void LIS302DL_DataRateCmd(uint8_t DataRateValue) {
uint8_t tmpreg;
/* Read CTRL_REG1 register */
LIS302DL_Read(&tmpreg, LIS302DL_CTRL_REG1_ADDR, 1);
/* Set new Data rate configuration */
tmpreg &= (uint8_t) ~LIS302DL_DATARATE_400;
tmpreg |= DataRateValue;
/* Write value to MEMS CTRL_REG1 regsister */
LIS302DL_Write(&tmpreg, LIS302DL_CTRL_REG1_ADDR, 1);
}
/**
* @brief Change the Full Scale of LIS302DL
* @param FS_value: new full scale value.
* This parameter can be one of the following values:
* @arg LIS302DL_FULLSCALE_2_3: +-2.3g
* @arg LIS302DL_FULLSCALE_9_2: +-9.2g
* @retval None
*/
void LIS302DL_FullScaleCmd(uint8_t FS_value) {
uint8_t tmpreg;
/* Read CTRL_REG1 register */
LIS302DL_Read(&tmpreg, LIS302DL_CTRL_REG1_ADDR, 1);
/* Set new full scale configuration */
tmpreg &= (uint8_t) ~LIS302DL_FULLSCALE_9_2;
tmpreg |= FS_value;
/* Write value to MEMS CTRL_REG1 regsister */
LIS302DL_Write(&tmpreg, LIS302DL_CTRL_REG1_ADDR, 1);
}
void LIS302DL_GetWakeupInterruptData(SPI_TypeDef* spi, LIS302DL_WakeupInterruptData* pData, uint8_t intNum) {
uint8_t tmpreg = 0x00;
LIS302DL_Read(&tmpreg, ((intNum & LIS302DL_INTERRUPT_NUM_2) ? LIS302DL_FF_WU_SRC2_REG_ADDR : LIS302DL_FF_WU_SRC1_REG_ADDR), 1);
// Map received data into the configuration; Data is delivered in BigEndian
pData->Active = tmpreg & (uint8_t)LIS302DL_BIT1 ? 0x01 : 0x00;
pData->Z_High = tmpreg & (uint8_t)LIS302DL_BIT2 ? 0x01 : 0x00;
pData->Z_Low = tmpreg & (uint8_t)LIS302DL_BIT3 ? 0x01 : 0x00;
pData->Y_High = tmpreg & (uint8_t)LIS302DL_BIT4 ? 0x01 : 0x00;
pData->Y_Low = tmpreg & (uint8_t)LIS302DL_BIT5 ? 0x01 : 0x00;
pData->X_High = tmpreg & (uint8_t)LIS302DL_BIT6 ? 0x01 : 0x00;
pData->X_Low = tmpreg & (uint8_t)LIS302DL_BIT7 ? 0x01 : 0x00;
}
/**
* @brief Change the lowpower mode for LIS302DL
* @param LowPowerMode: new state for the lowpower mode.
* This parameter can be one of the following values:
* @arg LIS302DL_LOWPOWERMODE_POWERDOWN: Power down mode
* @arg LIS302DL_LOWPOWERMODE_ACTIVE: Active mode
* @retval None
*/
void LIS302DL_LowpowerCmd(uint8_t LowPowerMode) {
uint8_t tmpreg;
/* Read CTRL_REG1 register */
LIS302DL_Read(&tmpreg, LIS302DL_CTRL_REG1_ADDR, 1);
/* Set new low power mode configuration */
tmpreg &= (uint8_t) ~LIS302DL_LOWPOWERMODE_ACTIVE;
tmpreg |= LowPowerMode;
/* Write value to MEMS CTRL_REG1 regsister */
LIS302DL_Write(&tmpreg, LIS302DL_CTRL_REG1_ADDR, 1);
}
void LIS302DL_GetClickInterruptConfiguration(SPI_TypeDef* spi, LIS302DL_ClickInterruptConfig* pConfig) {
uint8_t cnf = 0x00;
LIS302DL_Read(&cnf, LIS302DL_CLICK_CFG_REG_ADDR, 1);
// Map received data into the configuration; Data is delivered in BigEndian
pConfig->Latched = cnf & (uint8_t)LIS302DL_BIT1 ? 0x01 : 0x00;
pConfig->DoubleClick_Z = cnf & (uint8_t)LIS302DL_BIT2 ? 0x01 : 0x00;
pConfig->SingleClick_Z = cnf & (uint8_t)LIS302DL_BIT3 ? 0x01 : 0x00;
pConfig->DoubleClick_Y = cnf & (uint8_t)LIS302DL_BIT4 ? 0x01 : 0x00;
pConfig->SingleClick_Y = cnf & (uint8_t)LIS302DL_BIT5 ? 0x01 : 0x00;
pConfig->DoubleClick_X = cnf & (uint8_t)LIS302DL_BIT6 ? 0x01 : 0x00;
pConfig->DoubleClick_X = cnf & (uint8_t)LIS302DL_BIT7 ? 0x01 : 0x00;
}
void LIS302DL_GetClickInterruptData(SPI_TypeDef* spi, LIS302DL_ClickInterruptData* pData) {
uint8_t tmpreg = 0x00;
LIS302DL_Read(&tmpreg, LIS302DL_CLICK_SRC_REG_ADDR, 1);
// Map received data into the configuration; Data is delivered in BigEndian
pData->Active = tmpreg & (uint8_t)LIS302DL_BIT1 ? 0x01 : 0x00;
pData->Double_Z = tmpreg & (uint8_t)LIS302DL_BIT2 ? 0x01 : 0x00;
pData->Single_Z = tmpreg & (uint8_t)LIS302DL_BIT3 ? 0x01 : 0x00;
pData->Double_Y = tmpreg & (uint8_t)LIS302DL_BIT4 ? 0x01 : 0x00;
pData->Single_Y = tmpreg & (uint8_t)LIS302DL_BIT5 ? 0x01 : 0x00;
pData->Double_X = tmpreg & (uint8_t)LIS302DL_BIT6 ? 0x01 : 0x00;
pData->Single_X = tmpreg & (uint8_t)LIS302DL_BIT7 ? 0x01 : 0x00;
}
void LIS302DL_GetWakeupInterruptConfiguration(SPI_TypeDef* spi, LIS302DL_WakeupInterruptConfig* pConfig, uint8_t intNum) {
uint8_t cnf = 0x00;
LIS302DL_Read(&cnf, ((intNum & LIS302DL_INTERRUPT_NUM_2) ? LIS302DL_FF_WU_CFG2_REG_ADDR : LIS302DL_FF_WU_CFG1_REG_ADDR), 1);
// Map received data into the configuration; Data is delivered in BigEndian
pConfig->CombineInterrupts = cnf & (uint8_t)LIS302DL_BIT0 ? 0x01 : 0x00;
pConfig->Latched = cnf & (uint8_t)LIS302DL_BIT1 ? 0x01 : 0x00;
pConfig->Z_High = cnf & (uint8_t)LIS302DL_BIT2 ? 0x01 : 0x00;
pConfig->Z_Low = cnf & (uint8_t)LIS302DL_BIT3 ? 0x01 : 0x00;
pConfig->Y_High = cnf & (uint8_t)LIS302DL_BIT4 ? 0x01 : 0x00;
pConfig->Y_Low = cnf & (uint8_t)LIS302DL_BIT5 ? 0x01 : 0x00;
pConfig->X_High = cnf & (uint8_t)LIS302DL_BIT6 ? 0x01 : 0x00;
pConfig->X_Low = cnf & (uint8_t)LIS302DL_BIT7 ? 0x01 : 0x00;
}
void LIS302DL_GetConfiguration(SPI_TypeDef* spi, volatile LIS302DL_Config* pConfig) {
uint8_t cnf = 0x00;
LIS302DL_Read(&cnf, LIS302DL_CTRL_REG1_ADDR, 1);
// Map received data into the configuration; Data is delivered in BigEndian
pConfig->DataRate = cnf & (uint8_t)LIS302DL_BIT0 ? 0x01 : 0x00;
pConfig->PowerDown = cnf & (uint8_t)LIS302DL_BIT1 ? 0x01 : 0x00;
pConfig->FullScale = cnf & (uint8_t)LIS302DL_BIT2 ? 0x01 : 0x00;
pConfig->SelfTest_P = cnf & (uint8_t)LIS302DL_BIT3 ? 0x01 : 0x00;
pConfig->SelfTest_M = cnf & (uint8_t)LIS302DL_BIT4 ? 0x01 : 0x00;
pConfig->ZAxisEnabled = cnf & (uint8_t)LIS302DL_BIT5 ? 0x01 : 0x00;
pConfig->YAxisEnabled = cnf & (uint8_t)LIS302DL_BIT6 ? 0x01 : 0x00;
pConfig->XAxisEnabled = cnf & (uint8_t)LIS302DL_BIT7 ? 0x01 : 0x00;
}
void EXTI0_IRQHandler(void) {
if (EXTI_GetITStatus(EXTI_Line0 ) != RESET) {
portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
unsigned long ulDummy;
ulDummy = portSET_INTERRUPT_MASK_FROM_ISR();
{
uint8_t buffer[6];
LIS302DL_Read(buffer, LIS302DL_OUT_X_ADDR, 6);
xQueueSendFromISR(queue, &(buffer[4]), &xHigherPriorityTaskWoken);
EXTI_ClearITPendingBit(EXTI_Line0 );
}
portCLEAR_INTERRUPT_MASK_FROM_ISR( ulDummy);
portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);
}
}
void LIS302DL_GlobalInterruptConfiguration(SPI_TypeDef* spi, LIS302DL_GlobalInterruptConfig* pConfig) {
// Get the current configuration
uint8_t cnf = 0x00;
LIS302DL_Read(&cnf, LIS302DL_CTRL_REG2_ADDR, 1);
// Unset the bits we want configure
cnf &= (uint8_t)~(LIS302DL_BIT3 | LIS302DL_BIT4 | LIS302DL_BIT5 | LIS302DL_BIT6 | LIS302DL_BIT7);
// Map the configuration to be always BigEndian
cnf |= pConfig->SendData ? (uint8_t)LIS302DL_BIT3 : 0x00;
cnf |= pConfig->Interrupt_1 ? (uint8_t)LIS302DL_BIT4 : 0x00;
cnf |= pConfig->Interrupt_2 ? (uint8_t)LIS302DL_BIT5 : 0x00;
cnf |= (pConfig->CutOffFrequency <= (uint8_t)LIS302DL_HIGHPASS_CUTOFF_SLOW) ? pConfig->CutOffFrequency : 0x00;
LIS302DL_Write(&cnf, LIS302DL_CTRL_REG2_ADDR, 1);
}
/**
* @brief Set LIS302DL Internal High Pass Filter configuration.
* @param LIS302DL_Filter_ConfigTypeDef: pointer to a LIS302DL_FilterConfig_TypeDef
* structure that contains the configuration setting for the LIS302DL Filter.
* @retval None
*/
void LIS302DL_FilterConfig(LIS302DL_FilterConfigTypeDef *LIS302DL_FilterConfigStruct) {
uint8_t ctrl = 0x00;
/* Read CTRL_REG2 register */
LIS302DL_Read(&ctrl, LIS302DL_CTRL_REG2_ADDR, 1);
/* Clear high pass filter cut-off level, interrupt and data selection bits*/
ctrl &= (uint8_t) ~(LIS302DL_FILTEREDDATASELECTION_OUTPUTREGISTER | \
LIS302DL_HIGHPASSFILTER_LEVEL_3 | \
LIS302DL_HIGHPASSFILTERINTERRUPT_1_2);
/* Configure MEMS high pass filter cut-off level, interrupt and data selection bits */
ctrl |= (uint8_t) (LIS302DL_FilterConfigStruct->HighPassFilter_Data_Selection | \
LIS302DL_FilterConfigStruct->HighPassFilter_CutOff_Frequency | \
LIS302DL_FilterConfigStruct->HighPassFilter_Interrupt);
/* Write value to MEMS CTRL_REG2 register */
LIS302DL_Write(&ctrl, LIS302DL_CTRL_REG2_ADDR, 1);
}
/**
* @brief Configure MEMS operation
* @param None
* @retval None
*/
void MEMS_Config(void)
{
LIS302DL_InitTypeDef LIS302DL_InitStruct;
LIS302DL_FilterConfigTypeDef LIS302DL_FilterStruct;
/* Set configuration of LIS302DL*/
LIS302DL_InitStruct.Power_Mode = LIS302DL_LOWPOWERMODE_ACTIVE;
LIS302DL_InitStruct.Output_DataRate = LIS302DL_DATARATE_100;
LIS302DL_InitStruct.Axes_Enable = LIS302DL_X_ENABLE | LIS302DL_Y_ENABLE;
LIS302DL_InitStruct.Full_Scale = LIS302DL_FULLSCALE_2_3;
LIS302DL_InitStruct.Self_Test = LIS302DL_SELFTEST_NORMAL;
LIS302DL_Init(&LIS302DL_InitStruct);
LIS302DL_FilterStruct.HighPassFilter_Data_Selection = LIS302DL_FILTEREDDATASELECTION_OUTPUTREGISTER;
LIS302DL_FilterStruct.HighPassFilter_CutOff_Frequency = LIS302DL_HIGHPASSFILTER_LEVEL_1;
LIS302DL_FilterStruct.HighPassFilter_Interrupt = LIS302DL_HIGHPASSFILTERINTERRUPT_OFF;
LIS302DL_FilterConfig(&LIS302DL_FilterStruct);
LIS302DL_Read(Buffer, LIS302DL_OUT_X_ADDR, 4);
XOffset = Buffer[0];
YOffset = Buffer[2];
}
void LIS302DL_Write(SPI_TypeDef* spi, uint8_t* pBuffer, uint8_t writeAddr, uint16_t numByteToWrite) {
// For writing multiple bytes we need to set bit 1 (MS)
if (numByteToWrite > 1) {
writeAddr |= (uint8_t)LIS302DL_BIT1;
}
// Set chip select Low at the start of the transmission
LIS302DL_CS_LOW();
LIS302DL_Read(spi);
// Send the Address of the indexed register
_LIS302DL_SendByte(spi, writeAddr);
// Send the data that will be written into the device (MSB First)
while (numByteToWrite >= 1) {
_LIS302DL_SendByte(spi, *pBuffer);
numByteToWrite--;
pBuffer++;
}
// Set chip select High at the end of the transmission
LIS302DL_CS_HIGH();
}
/**
* @brief Reads from LIS302DL_CLICK_SRC_REG_ADDR to unlatch the interrupt.
*/
void Clear_Accel_Int(void){
uint8_t junk[2];
LIS302DL_Read( junk, LIS302DL_CLICK_SRC_REG_ADDR, 2);
}
/**
* @brief Execute the demo application.
* @param None
* @retval None
*/
static void Demo_Exec(void)
{
RCC_ClocksTypeDef RCC_Clocks;
uint8_t togglecounter = 0x00;
while(1)
{
DemoEnterCondition = 0x00;
/* Reset UserButton_Pressed variable */
UserButtonPressed = 0x00;
/* Initialize LEDs to be managed by GPIO */
STM_EVAL_LEDInit(LED4);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED5);
STM_EVAL_LEDInit(LED6);
/* SysTick end of count event each 10ms */
RCC_GetClocksFreq(&RCC_Clocks);
SysTick_Config(RCC_Clocks.HCLK_Frequency / 100);
/* Turn OFF all LEDs */
STM_EVAL_LEDOff(LED4);
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED5);
STM_EVAL_LEDOff(LED6);
/* Waiting User Button is pressed */
while (UserButtonPressed == 0x00)
{
/* Toggle LED4 */
STM_EVAL_LEDToggle(LED4);
Delay(10);
/* Toggle LED4 */
STM_EVAL_LEDToggle(LED3);
Delay(10);
/* Toggle LED4 */
STM_EVAL_LEDToggle(LED5);
Delay(10);
/* Toggle LED4 */
STM_EVAL_LEDToggle(LED6);
Delay(10);
togglecounter ++;
if (togglecounter == 0x10)
{
togglecounter = 0x00;
while (togglecounter < 0x10)
{
STM_EVAL_LEDToggle(LED4);
STM_EVAL_LEDToggle(LED3);
STM_EVAL_LEDToggle(LED5);
STM_EVAL_LEDToggle(LED6);
Delay(10);
togglecounter ++;
}
togglecounter = 0x00;
}
}
/* Waiting User Button is Released */
while (STM_EVAL_PBGetState(BUTTON_USER) == Bit_SET)
{}
UserButtonPressed = 0x00;
/* TIM4 channels configuration */
TIM4_Config();
/* Disable all Timer4 channels */
TIM_CCxCmd(TIM4, TIM_Channel_1, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_2, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_3, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_4, DISABLE);
/* MEMS configuration */
LIS302DL_InitStruct.Power_Mode = LIS302DL_LOWPOWERMODE_ACTIVE;
LIS302DL_InitStruct.Output_DataRate = LIS302DL_DATARATE_100;
LIS302DL_InitStruct.Axes_Enable = LIS302DL_XYZ_ENABLE;
LIS302DL_InitStruct.Full_Scale = LIS302DL_FULLSCALE_2_3;
LIS302DL_InitStruct.Self_Test = LIS302DL_SELFTEST_NORMAL;
LIS302DL_Init(&LIS302DL_InitStruct);
/* Required delay for the MEMS Accelerometre: Turn-on time = 3/Output data Rate
= 3/100 = 30ms */
Delay(30);
DemoEnterCondition = 0x01;
/* MEMS High Pass Filter configuration */
LIS302DL_FilterStruct.HighPassFilter_Data_Selection = LIS302DL_FILTEREDDATASELECTION_OUTPUTREGISTER;
LIS302DL_FilterStruct.HighPassFilter_CutOff_Frequency = LIS302DL_HIGHPASSFILTER_LEVEL_1;
LIS302DL_FilterStruct.HighPassFilter_Interrupt = LIS302DL_HIGHPASSFILTERINTERRUPT_1_2;
LIS302DL_FilterConfig(&LIS302DL_FilterStruct);
LIS302DL_Read(Buffer, LIS302DL_OUT_X_ADDR, 6);
X_Offset = Buffer[0];
Y_Offset = Buffer[2];
Z_Offset = Buffer[4];
/* USB configuration */
Demo_USBConfig();
/* Waiting User Button is pressed */
while (UserButtonPressed == 0x00)
{}
/* Waiting User Button is Released */
while (STM_EVAL_PBGetState(BUTTON_USER) == Bit_SET)
{}
/* Disable SPI1 used to drive the MEMS accelerometre */
SPI_Cmd(LIS302DL_SPI, DISABLE);
/* Disconnect the USB device */
DCD_DevDisconnect(&USB_OTG_dev);
USB_OTG_StopDevice(&USB_OTG_dev);
}
}