标题: LIS2DW12驱动stm32源码 [打印本页]
作者: liuxinwei12    时间: 2018-4-24 12:49
标题: LIS2DW12驱动stm32源码
RT。。。。。

单片机源程序如下:
  1. /******************** (C) COPYRIGHT 2016 STMicroelectronics ********************
  2. * File Name          : LIS2DW12_ACC_driver.c
  3. * Author             : MEMS Application Team
  4. * Version            : v1.1
  5. * Date               : 11 May 2017
  6. * Description        : EKSTM32 main file
  7. *
  8. ********************************************************************************
  9. * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  10. * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
  11. * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
  12. * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
  13. * CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
  14. * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  15. *
  16. * THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS.
  17. *******************************************************************************/

  19. /* Includes ------------------------------------------------------------------*/
  20. #include "LIS2DW12_ACC_driver.h"
  21. #include "spi.h"

  23. /* Private typedef -----------------------------------------------------------*/

  25. /* Private define ------------------------------------------------------------*/

  27. /* Private macro -------------------------------------------------------------*/

  29. /* Private variables ---------------------------------------------------------*/

  31. /* Private functions ---------------------------------------------------------*/

  33. /************** Generic Function  *******************/

  35. /*******************************************************************************
  36.   * Function Name    : LIS2DW12_ACC_WriteReg
  37.   * Description    : Generic Writing function. It must be fullfilled with either
  38.   *          : I2C or SPI writing function
  39.   * Input        : Register Address, ptr to buffer to be written,
  40.   *                                 length of buffer
  41.   * Output      : None
  42.   * Return      : None
  43. *******************************************************************************/
  44. status_t LIS2DW12_ACC_WriteReg(void *handle, u8_t Reg, u8_t *Bufp, u16_t len)
  45. {
  46.   /* Example
  47.     HAL_GPIO_WritePin(CS_DEV_GPIO_Port, CS_DEV_Pin, GPIO_PIN_RESET);  
  48.     HAL_SPI_Transmit(&hspi2, &Reg, 1, 1000);
  49.     HAL_SPI_Transmit(&hspi2, Bufp, len, 1000);
  50.     HAL_GPIO_WritePin(CS_DEV_GPIO_Port, CS_DEV_Pin, GPIO_PIN_SET);   
  51.   */
  52.   return MEMS_SUCCESS;
  53. }

  55. /*******************************************************************************
  56.   * Function Name    : LIS2DW12_ACC_ReadReg
  57.   * Description    : Generic Reading function. It must be fullfilled with either
  58.   *          : I2C or SPI writing function
  59.   * Input        : Register Address, ptr to buffer to be read,
  60.   *                                 length of buffer
  61.   * Output      : None
  62.   * Return      : None
  63. *******************************************************************************/
  64. status_t LIS2DW12_ACC_ReadReg(void *handle, u8_t Reg, u8_t *Bufp, u16_t len)
  65. {
  66.   /* Example
  67.     HAL_GPIO_WritePin(CS_DEV_GPIO_Port, CS_DEV_Pin, GPIO_PIN_RESET);
  68.     uint8_t dummy = Reg|0x80;
  69.     HAL_SPI_Transmit(&hspi2, &dummy, 1, 1000);   
  70.     HAL_SPI_Receive(&hspi2, Bufp, len, 1000);
  71.     HAL_GPIO_WritePin(CS_DEV_GPIO_Port, CS_DEV_Pin, GPIO_PIN_SET);
  72.   */
  73.   return MEMS_SUCCESS;
  74. }

  76. /**************** Base Function  *******************/

  78. /*******************************************************************************
  79.   * Function Name  : LIS2DW12_ACC_R_WhoAmI
  80.   * Description    : Read WHO_AM_I_BIT
  81.   * Input          : Pointer to u8_t
  82.   * Output         : Status of WHO_AM_I_BIT
  83.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  84. *******************************************************************************/
  85. status_t LIS2DW12_ACC_R_WhoAmI(void *handle, u8_t *value)
  86. {
  87.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_WHO_AM_I_REG, (u8_t *)value , 1) )
  88.     return MEMS_ERROR;
  89.   
  90.   *value &= LIS2DW12_ACC_WHO_AM_I_BIT_MASK; //coerce  
  91.   *value = *value >> LIS2DW12_ACC_WHO_AM_I_BIT_POSITION; //mask  
  92.   
  93.     return MEMS_SUCCESS;
  94. }

  96. /*******************************************************************************
  97.   * Function Name  : LIS2DW12_ACC_W_OutputDataRate
  98.   * Description    : Write ODR
  99.   * Input          : LIS2DW12_ACC_ODR_t
  100.   * Output         : None
  101.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  102. *******************************************************************************/
  103. status_t  LIS2DW12_ACC_W_OutputDataRate(void *handle, LIS2DW12_ACC_ODR_t newValue)
  104. {
  105.   u8_t value;
  106.   
  107.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL1, &value, 1) )
  108.     return MEMS_ERROR;
  109.   
  110.   value &= ~LIS2DW12_ACC_ODR_MASK;
  111.   value |= newValue;
  112.   
  113.   if( !LIS2DW12_ACC_WriteReg(handle, LIS2DW12_ACC_CTRL1, &value, 1) )
  114.     return MEMS_ERROR;
  115.   
  116.   return MEMS_SUCCESS;
  117. }

  119. /*******************************************************************************
  120.   * Function Name  : LIS2DW12_ACC_R_OutputDataRate
  121.   * Description    : Read ODR
  122.   * Input          : Pointer to LIS2DW12_ACC_ODR_t
  123.   * Output         : Status of ODR see LIS2DW12_ACC_ODR_t
  124.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  125. *******************************************************************************/
  126. status_t LIS2DW12_ACC_R_OutputDataRate(void *handle, LIS2DW12_ACC_ODR_t *value)
  127. {
  128.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL1, (u8_t *)value , 1) )
  129.     return MEMS_ERROR;
  130.   
  131.   *value &= LIS2DW12_ACC_ODR_MASK; //mask
  132.   
  133.   return MEMS_SUCCESS;
  134. }

  136. /*******************************************************************************
  137.   * Function Name  : LIS2DW12_ACC_W_FullScaleSelection
  138.   * Description    : Write FS
  139.   * Input          : LIS2DW12_ACC_FS_t
  140.   * Output         : None
  141.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  142. *******************************************************************************/
  143. status_t  LIS2DW12_ACC_W_FullScaleSelection(void *handle, LIS2DW12_ACC_FS_t newValue)
  144. {
  145.   u8_t value;
  146.   
  147.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL6, &value, 1) )
  148.     return MEMS_ERROR;
  149.   
  150.   value &= ~LIS2DW12_ACC_FS_MASK;
  151.   value |= newValue;
  152.   
  153.   if( !LIS2DW12_ACC_WriteReg(handle, LIS2DW12_ACC_CTRL6, &value, 1) )
  154.     return MEMS_ERROR;
  155.   
  156.   return MEMS_SUCCESS;
  157. }

  159. /*******************************************************************************
  160.   * Function Name  : LIS2DW12_ACC_R_FullScaleSelection
  161.   * Description    : Read FS
  162.   * Input          : Pointer to LIS2DW12_ACC_FS_t
  163.   * Output         : Status of FS see LIS2DW12_ACC_FS_t
  164.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  165. *******************************************************************************/
  166. status_t LIS2DW12_ACC_R_FullScaleSelection(void *handle, LIS2DW12_ACC_FS_t *value)
  167. {
  168.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL6, (u8_t *)value , 1) )
  169.     return MEMS_ERROR;
  170.   
  171.   *value &= LIS2DW12_ACC_FS_MASK; //mask
  172.   
  173.   return MEMS_SUCCESS;
  174. }

  176. /*******************************************************************************
  177.   * Function Name  : LIS2DW12_ACC_W_BlockDataUpdate
  178.   * Description    : Write BDU
  179.   * Input          : LIS2DW12_ACC_BDU_t
  180.   * Output         : None
  181.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  182. *******************************************************************************/
  183. status_t  LIS2DW12_ACC_W_BlockDataUpdate(void *handle, LIS2DW12_ACC_BDU_t newValue)
  184. {
  185.   u8_t value;
  186.   
  187.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL2, &value, 1) )
  188.     return MEMS_ERROR;
  189.   
  190.   value &= ~LIS2DW12_ACC_BDU_MASK;
  191.   value |= newValue;
  192.   
  193.   if( !LIS2DW12_ACC_WriteReg(handle, LIS2DW12_ACC_CTRL2, &value, 1) )
  194.     return MEMS_ERROR;
  195.   
  196.   return MEMS_SUCCESS;
  197. }

  199. /*******************************************************************************
  200.   * Function Name  : LIS2DW12_ACC_R_BlockDataUpdate
  201.   * Description    : Read BDU
  202.   * Input          : Pointer to LIS2DW12_ACC_BDU_t
  203.   * Output         : Status of BDU see LIS2DW12_ACC_BDU_t
  204.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  205. *******************************************************************************/
  206. status_t LIS2DW12_ACC_R_BlockDataUpdate(void *handle, LIS2DW12_ACC_BDU_t *value)
  207. {
  208.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL2, (u8_t *)value , 1) )
  209.     return MEMS_ERROR;
  210.   
  211.   *value &= LIS2DW12_ACC_BDU_MASK; //mask
  212.   
  213.   return MEMS_SUCCESS;
  214. }

  216. /*******************************************************************************
  217.   * Function Name  : status_t LIS2DW12_ACC_Get_Acceleration(u8_t *buff)
  218.   * Description    : Read Acceleration output register
  219.   * Input          : pointer to [u8_t]
  220.   * Output         : Acceleration buffer u8_t
  221.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  222. *******************************************************************************/
  223. status_t LIS2DW12_ACC_Get_Acceleration(void *handle, u8_t *buff)
  224. {
  225.   u8_t i, j, k;
  226.   u8_t numberOfByteForDimension;
  227.   
  228.   numberOfByteForDimension=6/3;
  229.   
  230.   k=0;
  231.   for (i=0; i<3;i++ )
  232.   {
  233.     for (j=0; j<numberOfByteForDimension;j++ )
  234.     {  
  235.       if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_OUT_X_L+k, &buff[k], 1))
  236.         return MEMS_ERROR;
  237.       k++;  
  238.     }
  239.   }
  240.   
  241.   return MEMS_SUCCESS;
  242. }

  244. /*******************************************************************************
  245.   * Function Name  : status_t LIS2DW12_ACC_Get_Temperature(u8_t *buff)
  246.   * Description    : Read Temperature output register
  247.   * Input          : pointer to [u8_t]
  248.   * Output         : Temperature buffer u8_t
  249.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  250. *******************************************************************************/
  251. status_t LIS2DW12_ACC_Get_Temperature(void *handle, u8_t *buff)
  252. {
  253.   u8_t i, j, k;
  254.   u8_t numberOfByteForDimension;
  255.   
  256.   numberOfByteForDimension=2/1;
  257.   
  258.   k=0;
  259.   for (i=0; i<1;i++ )
  260.   {
  261.     for (j=0; j<numberOfByteForDimension;j++ )
  262.     {  
  263.       if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_OUT_T_L+k, &buff[k], 1))
  264.         return MEMS_ERROR;
  265.       k++;  
  266.     }
  267.   }
  268.   
  269.   return MEMS_SUCCESS;
  270. }

  272. /**************** Advanced Function  *******************/

  274. /*******************************************************************************
  275.   * Function Name  : LIS2DW12_ACC_W_LowPowerModeSelection
  276.   * Description    : Write LP_MODE
  277.   * Input          : LIS2DW12_ACC_LP_MODE_t
  278.   * Output         : None
  279.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  280. *******************************************************************************/
  281. status_t  LIS2DW12_ACC_W_LowPowerModeSelection(void *handle, LIS2DW12_ACC_LP_MODE_t newValue)
  282. {
  283.   u8_t value;
  284.   
  285.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL1, &value, 1) )
  286.     return MEMS_ERROR;
  287.   
  288.   value &= ~LIS2DW12_ACC_LP_MODE_MASK;
  289.   value |= newValue;
  290.   
  291.   if( !LIS2DW12_ACC_WriteReg(handle, LIS2DW12_ACC_CTRL1, &value, 1) )
  292.     return MEMS_ERROR;
  293.   
  294.   return MEMS_SUCCESS;
  295. }

  297. /*******************************************************************************
  298.   * Function Name  : LIS2DW12_ACC_R_LowPowerModeSelection
  299.   * Description    : Read LP_MODE
  300.   * Input          : Pointer to LIS2DW12_ACC_LP_MODE_t
  301.   * Output         : Status of LP_MODE see LIS2DW12_ACC_LP_MODE_t
  302.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  303. *******************************************************************************/
  304. status_t LIS2DW12_ACC_R_LowPowerModeSelection(void *handle, LIS2DW12_ACC_LP_MODE_t *value)
  305. {
  306.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL1, (u8_t *)value , 1) )
  307.     return MEMS_ERROR;
  308.   
  309.   *value &= LIS2DW12_ACC_LP_MODE_MASK; //mask
  310.   
  311.   return MEMS_SUCCESS;
  312. }

  314. /*******************************************************************************
  315.   * Function Name  : LIS2DW12_ACC_W_ModeSelection
  316.   * Description    : Write MODE
  317.   * Input          : LIS2DW12_ACC_MODE_t
  318.   * Output         : None
  319.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  320. *******************************************************************************/
  321. status_t  LIS2DW12_ACC_W_ModeSelection(void *handle, LIS2DW12_ACC_MODE_t newValue)
  322. {
  323.   u8_t value;
  324.   
  325.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL1, &value, 1) )
  326.     return MEMS_ERROR;
  327.   
  328.   value &= ~LIS2DW12_ACC_MODE_MASK;
  329.   value |= newValue;
  330.   
  331.   if( !LIS2DW12_ACC_WriteReg(handle, LIS2DW12_ACC_CTRL1, &value, 1) )
  332.     return MEMS_ERROR;
  333.   
  334.   return MEMS_SUCCESS;
  335. }

  337. /*******************************************************************************
  338.   * Function Name  : LIS2DW12_ACC_R_ModeSelection
  339.   * Description    : Read MODE
  340.   * Input          : Pointer to LIS2DW12_ACC_MODE_t
  341.   * Output         : Status of MODE see LIS2DW12_ACC_MODE_t
  342.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  343. *******************************************************************************/
  344. status_t LIS2DW12_ACC_R_ModeSelection(void *handle, LIS2DW12_ACC_MODE_t *value)
  345. {
  346.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL1, (u8_t *)value , 1) )
  347.     return MEMS_ERROR;
  348.   
  349.   *value &= LIS2DW12_ACC_MODE_MASK; //mask
  350.   
  351.   return MEMS_SUCCESS;
  352. }

  354. /*******************************************************************************
  355.   * Function Name  : LIS2DW12_ACC_W_SPI_mode_selection
  356.   * Description    : Write SIM
  357.   * Input          : LIS2DW12_ACC_SIM_t
  358.   * Output         : None
  359.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  360. *******************************************************************************/
  361. status_t  LIS2DW12_ACC_W_SPI_mode_selection(void *handle, LIS2DW12_ACC_SIM_t newValue)
  362. {
  363.   u8_t value;
  364.   
  365.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL2, &value, 1) )
  366.     return MEMS_ERROR;
  367.   
  368.   value &= ~LIS2DW12_ACC_SIM_MASK;
  369.   value |= newValue;
  370.   
  371.   if( !LIS2DW12_ACC_WriteReg(handle, LIS2DW12_ACC_CTRL2, &value, 1) )
  372.     return MEMS_ERROR;
  373.   
  374.   return MEMS_SUCCESS;
  375. }

  377. /*******************************************************************************
  378.   * Function Name  : LIS2DW12_ACC_R_SPI_mode_selection
  379.   * Description    : Read SIM
  380.   * Input          : Pointer to LIS2DW12_ACC_SIM_t
  381.   * Output         : Status of SIM see LIS2DW12_ACC_SIM_t
  382.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  383. *******************************************************************************/
  384. status_t LIS2DW12_ACC_R_SPI_mode_selection(void *handle, LIS2DW12_ACC_SIM_t *value)
  385. {
  386.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL2, (u8_t *)value , 1) )
  387.     return MEMS_ERROR;
  388.   
  389.   *value &= LIS2DW12_ACC_SIM_MASK; //mask
  390.   
  391.   return MEMS_SUCCESS;
  392. }

  394. /*******************************************************************************
  395.   * Function Name  : LIS2DW12_ACC_W_I2C_status
  396.   * Description    : Write I2C_DISABLE
  397.   * Input          : LIS2DW12_ACC_I2C_DISABLE_t
  398.   * Output         : None
  399.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  400. *******************************************************************************/
  401. status_t  LIS2DW12_ACC_W_I2C_status(void *handle, LIS2DW12_ACC_I2C_DISABLE_t newValue)
  402. {
  403.   u8_t value;
  404.   
  405.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL2, &value, 1) )
  406.     return MEMS_ERROR;
  407.   
  408.   value &= ~LIS2DW12_ACC_I2C_DISABLE_MASK;
  409.   value |= newValue;
  410.   
  411.   if( !LIS2DW12_ACC_WriteReg(handle, LIS2DW12_ACC_CTRL2, &value, 1) )
  412.     return MEMS_ERROR;
  413.   
  414.   return MEMS_SUCCESS;
  415. }

  417. /*******************************************************************************
  418.   * Function Name  : LIS2DW12_ACC_R_I2C_status
  419.   * Description    : Read I2C_DISABLE
  420.   * Input          : Pointer to LIS2DW12_ACC_I2C_DISABLE_t
  421.   * Output         : Status of I2C_DISABLE see LIS2DW12_ACC_I2C_DISABLE_t
  422.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  423. *******************************************************************************/
  424. status_t LIS2DW12_ACC_R_I2C_status(void *handle, LIS2DW12_ACC_I2C_DISABLE_t *value)
  425. {
  426.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL2, (u8_t *)value , 1) )
  427.     return MEMS_ERROR;
  428.   
  429.   *value &= LIS2DW12_ACC_I2C_DISABLE_MASK; //mask
  430.   
  431.   return MEMS_SUCCESS;
  432. }

  434. /*******************************************************************************
  435.   * Function Name  : LIS2DW12_ACC_W_AutoIncrementedWithMultipleAccess
  436.   * Description    : Write IF_ADD_INC
  437.   * Input          : LIS2DW12_ACC_IF_ADD_INC_t
  438.   * Output         : None
  439.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  440. *******************************************************************************/
  441. status_t  LIS2DW12_ACC_W_AutoIncrementedWithMultipleAccess(void *handle, LIS2DW12_ACC_IF_ADD_INC_t newValue)
  442. {
  443.   u8_t value;
  444.   
  445.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL2, &value, 1) )
  446.     return MEMS_ERROR;
  447.   
  448.   value &= ~LIS2DW12_ACC_IF_ADD_INC_MASK;
  449.   value |= newValue;
  450.   
  451.   if( !LIS2DW12_ACC_WriteReg(handle, LIS2DW12_ACC_CTRL2, &value, 1) )
  452.     return MEMS_ERROR;
  453.   
  454.   return MEMS_SUCCESS;
  455. }

  457. /*******************************************************************************
  458.   * Function Name  : LIS2DW12_ACC_R_AutoIncrementedWithMultipleAccess
  459.   * Description    : Read IF_ADD_INC
  460.   * Input          : Pointer to LIS2DW12_ACC_IF_ADD_INC_t
  461.   * Output         : Status of IF_ADD_INC see LIS2DW12_ACC_IF_ADD_INC_t
  462.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  463. *******************************************************************************/
  464. status_t LIS2DW12_ACC_R_AutoIncrementedWithMultipleAccess(void *handle, LIS2DW12_ACC_IF_ADD_INC_t *value)
  465. {
  466.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL2, (u8_t *)value , 1) )
  467.     return MEMS_ERROR;
  468.   
  469.   *value &= LIS2DW12_ACC_IF_ADD_INC_MASK; //mask
  470.   
  471.   return MEMS_SUCCESS;
  472. }

  474. /*******************************************************************************
  475.   * Function Name  : LIS2DW12_ACC_W_SoftReset
  476.   * Description    : Write SOFT_RESET
  477.   * Input          : LIS2DW12_ACC_SOFT_RESET_t
  478.   * Output         : None
  479.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  480. *******************************************************************************/
  481. status_t  LIS2DW12_ACC_W_SoftReset(void *handle, LIS2DW12_ACC_SOFT_RESET_t newValue)
  482. {
  483.   u8_t value;
  484.   
  485.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL2, &value, 1) )
  486.     return MEMS_ERROR;
  487.   
  488.   value &= ~LIS2DW12_ACC_SOFT_RESET_MASK;
  489.   value |= newValue;
  490.   
  491.   if( !LIS2DW12_ACC_WriteReg(handle, LIS2DW12_ACC_CTRL2, &value, 1) )
  492.     return MEMS_ERROR;
  493.   
  494.   return MEMS_SUCCESS;
  495. }

  497. /*******************************************************************************
  498.   * Function Name  : LIS2DW12_ACC_R_SoftReset
  499.   * Description    : Read SOFT_RESET
  500.   * Input          : Pointer to LIS2DW12_ACC_SOFT_RESET_t
  501.   * Output         : Status of SOFT_RESET see LIS2DW12_ACC_SOFT_RESET_t
  502.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  503. *******************************************************************************/
  504. status_t LIS2DW12_ACC_R_SoftReset(void *handle, LIS2DW12_ACC_SOFT_RESET_t *value)
  505. {
  506.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL2, (u8_t *)value , 1) )
  507.     return MEMS_ERROR;
  508.   
  509.   *value &= LIS2DW12_ACC_SOFT_RESET_MASK; //mask
  510.   
  511.   return MEMS_SUCCESS;
  512. }

  514. /*******************************************************************************
  515.   * Function Name  : LIS2DW12_ACC_W_Reboot
  516.   * Description    : Write BOOT
  517.   * Input          : LIS2DW12_ACC_BOOT_t
  518.   * Output         : None
  519.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  520. *******************************************************************************/
  521. status_t  LIS2DW12_ACC_W_Reboot(void *handle, LIS2DW12_ACC_BOOT_t newValue)
  522. {
  523.   u8_t value;
  524.   
  525.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL2, &value, 1) )
  526.     return MEMS_ERROR;
  527.   
  528.   value &= ~LIS2DW12_ACC_BOOT_MASK;
  529.   value |= newValue;
  530.   
  531.   if( !LIS2DW12_ACC_WriteReg(handle, LIS2DW12_ACC_CTRL2, &value, 1) )
  532.     return MEMS_ERROR;
  533.   
  534.   return MEMS_SUCCESS;
  535. }

  537. /*******************************************************************************
  538.   * Function Name  : LIS2DW12_ACC_R_Reboot
  539.   * Description    : Read BOOT
  540.   * Input          : Pointer to LIS2DW12_ACC_BOOT_t
  541.   * Output         : Status of BOOT see LIS2DW12_ACC_BOOT_t
  542.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  543. *******************************************************************************/
  544. status_t LIS2DW12_ACC_R_Reboot(void *handle, LIS2DW12_ACC_BOOT_t *value)
  545. {
  546.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL2, (u8_t *)value , 1) )
  547.     return MEMS_ERROR;
  548.   
  549.   *value &= LIS2DW12_ACC_BOOT_MASK; //mask
  550.   
  551.   return MEMS_SUCCESS;
  552. }

  554. /*******************************************************************************
  555.   * Function Name  : LIS2DW12_ACC_W_SingleLowPowerMode
  556.   * Description    : Write SLP_MODE_1
  557.   * Input          : LIS2DW12_ACC_SLP_MODE_1_t
  558.   * Output         : None
  559.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  560. *******************************************************************************/
  561. status_t  LIS2DW12_ACC_W_SingleLowPowerMode(void *handle, LIS2DW12_ACC_SLP_MODE_1_t newValue)
  562. {
  563.   u8_t value;
  564.   
  565.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL3, &value, 1) )
  566.     return MEMS_ERROR;
  567.   
  568.   value &= ~LIS2DW12_ACC_SLP_MODE_1_MASK;
  569.   value |= newValue;
  570.   
  571.   if( !LIS2DW12_ACC_WriteReg(handle, LIS2DW12_ACC_CTRL3, &value, 1) )
  572.     return MEMS_ERROR;
  573.   
  574.   return MEMS_SUCCESS;
  575. }

  577. /*******************************************************************************
  578.   * Function Name  : LIS2DW12_ACC_R_SingleLowPowerMode
  579.   * Description    : Read SLP_MODE_1
  580.   * Input          : Pointer to LIS2DW12_ACC_SLP_MODE_1_t
  581.   * Output         : Status of SLP_MODE_1 see LIS2DW12_ACC_SLP_MODE_1_t
  582.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  583. *******************************************************************************/
  584. status_t LIS2DW12_ACC_R_SingleLowPowerMode(void *handle, LIS2DW12_ACC_SLP_MODE_1_t *value)
  585. {
  586.   if( !LIS2DW12_ACC_ReadReg(handle, LIS2DW12_ACC_CTRL3, (u8_t *)value , 1) )
  587.     return MEMS_ERROR;
  588.   
  589.   *value &= LIS2DW12_ACC_SLP_MODE_1_MASK; //mask
  590.   
  591.   return MEMS_SUCCESS;
  592. }

  594. /*******************************************************************************
  595.   * Function Name  : LIS2DW12_ACC_W_SingleLowPowerModeSource
  596.   * Description    : Write SLP_MODE_SEL
  597.   * Input          : LIS2DW12_ACC_SLP_MODE_SEL_t
  598.   * Output         : None
  599.   * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
  600. *******************************************************************************/
  601. status_t  LIS2DW12_ACC_W_SingleLowPowerModeSource(void *handle, LIS2DW12_ACC_SLP_MODE_SEL_t newValue)
  602. {
  603.   u8_t value;
  604. ……………………

  606. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
LIS2DW12_ver1.1.zip (21.41 KB, 下载次数: 106)


作者: 阿斯蒂芬大幅    时间: 2018-6-27 00:02
请问有没有spi的程序
作者: wdliming    时间: 2019-2-14 13:43
谢谢分享~~~~
作者: hnlouji    时间: 2019-8-25 12:44
谢谢分享~~~~



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1