Subversion Repositories testOled

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /**
  2.   ******************************************************************************
  3.   * @file    stm32f1xx_hal_exti.c
  4.   * @author  MCD Application Team
  5.   * @brief   EXTI HAL module driver.
  6.   *          This file provides firmware functions to manage the following
  7.   *          functionalities of the Extended Interrupts and events controller (EXTI) peripheral:
  8.   *           + Initialization and de-initialization functions
  9.   *           + IO operation functions
  10.   *
  11.   @verbatim
  12.   ==============================================================================
  13.                     ##### EXTI Peripheral features #####
  14.   ==============================================================================
  15.   [..]
  16.     (+) Each Exti line can be configured within this driver.
  17.  
  18.     (+) Exti line can be configured in 3 different modes
  19.         (++) Interrupt
  20.         (++) Event
  21.         (++) Both of them
  22.  
  23.     (+) Configurable Exti lines can be configured with 3 different triggers
  24.         (++) Rising
  25.         (++) Falling
  26.         (++) Both of them
  27.  
  28.     (+) When set in interrupt mode, configurable Exti lines have two different
  29.         interrupts pending registers which allow to distinguish which transition
  30.         occurs:
  31.         (++) Rising edge pending interrupt
  32.         (++) Falling
  33.  
  34.     (+) Exti lines 0 to 15 are linked to gpio pin number 0 to 15. Gpio port can
  35.         be selected through multiplexer.
  36.  
  37.                      ##### How to use this driver #####
  38.   ==============================================================================
  39.   [..]
  40.  
  41.     (#) Configure the EXTI line using HAL_EXTI_SetConfigLine().
  42.         (++) Choose the interrupt line number by setting "Line" member from
  43.              EXTI_ConfigTypeDef structure.
  44.         (++) Configure the interrupt and/or event mode using "Mode" member from
  45.              EXTI_ConfigTypeDef structure.
  46.         (++) For configurable lines, configure rising and/or falling trigger
  47.              "Trigger" member from EXTI_ConfigTypeDef structure.
  48.         (++) For Exti lines linked to gpio, choose gpio port using "GPIOSel"
  49.              member from GPIO_InitTypeDef structure.
  50.  
  51.     (#) Get current Exti configuration of a dedicated line using
  52.         HAL_EXTI_GetConfigLine().
  53.         (++) Provide exiting handle as parameter.
  54.         (++) Provide pointer on EXTI_ConfigTypeDef structure as second parameter.
  55.  
  56.     (#) Clear Exti configuration of a dedicated line using HAL_EXTI_GetConfigLine().
  57.         (++) Provide exiting handle as parameter.
  58.  
  59.     (#) Register callback to treat Exti interrupts using HAL_EXTI_RegisterCallback().
  60.         (++) Provide exiting handle as first parameter.
  61.         (++) Provide which callback will be registered using one value from
  62.              EXTI_CallbackIDTypeDef.
  63.         (++) Provide callback function pointer.
  64.  
  65.     (#) Get interrupt pending bit using HAL_EXTI_GetPending().
  66.  
  67.     (#) Clear interrupt pending bit using HAL_EXTI_GetPending().
  68.  
  69.     (#) Generate software interrupt using HAL_EXTI_GenerateSWI().
  70.  
  71.   @endverbatim
  72.   ******************************************************************************
  73.   * @attention
  74.   *
  75.   * <h2><center>&copy; Copyright (c) 2019 STMicroelectronics.
  76.   * All rights reserved.</center></h2>
  77.   *
  78.   * This software component is licensed by ST under BSD 3-Clause license,
  79.   * the "License"; You may not use this file except in compliance with the
  80.   * License. You may obtain a copy of the License at:
  81.   *                        opensource.org/licenses/BSD-3-Clause
  82.   *
  83.   ******************************************************************************
  84.   */
  85.  
  86. /* Includes ------------------------------------------------------------------*/
  87. #include "stm32f1xx_hal.h"
  88.  
  89. /** @addtogroup STM32F1xx_HAL_Driver
  90.   * @{
  91.   */
  92.  
  93. /** @addtogroup EXTI
  94.   * @{
  95.   */
  96. /** MISRA C:2012 deviation rule has been granted for following rule:
  97.   * Rule-18.1_b - Medium: Array `EXTICR' 1st subscript interval [0,7] may be out
  98.   * of bounds [0,3] in following API :
  99.   * HAL_EXTI_SetConfigLine
  100.   * HAL_EXTI_GetConfigLine
  101.   * HAL_EXTI_ClearConfigLine
  102.   */
  103.  
  104. #ifdef HAL_EXTI_MODULE_ENABLED
  105.  
  106. /* Private typedef -----------------------------------------------------------*/
  107. /* Private defines -----------------------------------------------------------*/
  108. /** @defgroup EXTI_Private_Constants EXTI Private Constants
  109.   * @{
  110.   */
  111.  
  112. /**
  113.   * @}
  114.   */
  115.  
  116. /* Private macros ------------------------------------------------------------*/
  117. /* Private variables ---------------------------------------------------------*/
  118. /* Private function prototypes -----------------------------------------------*/
  119. /* Exported functions --------------------------------------------------------*/
  120.  
  121. /** @addtogroup EXTI_Exported_Functions
  122.   * @{
  123.   */
  124.  
  125. /** @addtogroup EXTI_Exported_Functions_Group1
  126.   *  @brief    Configuration functions
  127.   *
  128. @verbatim
  129.  ===============================================================================
  130.               ##### Configuration functions #####
  131.  ===============================================================================
  132.  
  133. @endverbatim
  134.   * @{
  135.   */
  136.  
  137. /**
  138.   * @brief  Set configuration of a dedicated Exti line.
  139.   * @param  hexti Exti handle.
  140.   * @param  pExtiConfig Pointer on EXTI configuration to be set.
  141.   * @retval HAL Status.
  142.   */
  143. HAL_StatusTypeDef HAL_EXTI_SetConfigLine(EXTI_HandleTypeDef *hexti, EXTI_ConfigTypeDef *pExtiConfig)
  144. {
  145.   uint32_t regval;
  146.   uint32_t linepos;
  147.   uint32_t maskline;
  148.  
  149.   /* Check null pointer */
  150.   if ((hexti == NULL) || (pExtiConfig == NULL))
  151.   {
  152.     return HAL_ERROR;
  153.   }
  154.  
  155.   /* Check parameters */
  156.   assert_param(IS_EXTI_LINE(pExtiConfig->Line));
  157.   assert_param(IS_EXTI_MODE(pExtiConfig->Mode));
  158.  
  159.   /* Assign line number to handle */
  160.   hexti->Line = pExtiConfig->Line;
  161.  
  162.   /* Compute line mask */
  163.   linepos = (pExtiConfig->Line & EXTI_PIN_MASK);
  164.   maskline = (1uL << linepos);
  165.  
  166.   /* Configure triggers for configurable lines */
  167.   if ((pExtiConfig->Line & EXTI_CONFIG) != 0x00u)
  168.   {
  169.     assert_param(IS_EXTI_TRIGGER(pExtiConfig->Trigger));
  170.  
  171.     /* Configure rising trigger */
  172.     /* Mask or set line */
  173.     if ((pExtiConfig->Trigger & EXTI_TRIGGER_RISING) != 0x00u)
  174.     {
  175.       EXTI->RTSR |= maskline;
  176.     }
  177.     else
  178.     {
  179.       EXTI->RTSR &= ~maskline;
  180.     }
  181.  
  182.     /* Configure falling trigger */
  183.     /* Mask or set line */
  184.     if ((pExtiConfig->Trigger & EXTI_TRIGGER_FALLING) != 0x00u)
  185.     {
  186.       EXTI->FTSR |= maskline;
  187.     }
  188.     else
  189.     {
  190.       EXTI->FTSR &= ~maskline;
  191.     }
  192.  
  193.  
  194.     /* Configure gpio port selection in case of gpio exti line */
  195.     if ((pExtiConfig->Line & EXTI_GPIO) == EXTI_GPIO)
  196.     {
  197.       assert_param(IS_EXTI_GPIO_PORT(pExtiConfig->GPIOSel));
  198.       assert_param(IS_EXTI_GPIO_PIN(linepos));
  199.      
  200.       regval = AFIO->EXTICR[linepos >> 2u];
  201.       regval &= ~(AFIO_EXTICR1_EXTI0 << (AFIO_EXTICR1_EXTI1_Pos * (linepos & 0x03u)));
  202.       regval |= (pExtiConfig->GPIOSel << (AFIO_EXTICR1_EXTI1_Pos * (linepos & 0x03u)));
  203.       AFIO->EXTICR[linepos >> 2u] = regval;
  204.     }
  205.   }
  206.  
  207.   /* Configure interrupt mode : read current mode */
  208.   /* Mask or set line */
  209.   if ((pExtiConfig->Mode & EXTI_MODE_INTERRUPT) != 0x00u)
  210.   {
  211.     EXTI->IMR |= maskline;
  212.   }
  213.   else
  214.   {
  215.     EXTI->IMR &= ~maskline;
  216.   }
  217.  
  218.   /* Configure event mode : read current mode */
  219.   /* Mask or set line */
  220.   if ((pExtiConfig->Mode & EXTI_MODE_EVENT) != 0x00u)
  221.   {
  222.     EXTI->EMR |= maskline;
  223.   }
  224.   else
  225.   {
  226.     EXTI->EMR &= ~maskline;
  227.   }
  228.  
  229.   return HAL_OK;
  230. }
  231.  
  232. /**
  233.   * @brief  Get configuration of a dedicated Exti line.
  234.   * @param  hexti Exti handle.
  235.   * @param  pExtiConfig Pointer on structure to store Exti configuration.
  236.   * @retval HAL Status.
  237.   */
  238. HAL_StatusTypeDef HAL_EXTI_GetConfigLine(EXTI_HandleTypeDef *hexti, EXTI_ConfigTypeDef *pExtiConfig)
  239. {
  240.   uint32_t regval;
  241.   uint32_t linepos;
  242.   uint32_t maskline;
  243.  
  244.   /* Check null pointer */
  245.   if ((hexti == NULL) || (pExtiConfig == NULL))
  246.   {
  247.     return HAL_ERROR;
  248.   }
  249.  
  250.   /* Check the parameter */
  251.   assert_param(IS_EXTI_LINE(hexti->Line));
  252.  
  253.   /* Store handle line number to configuration structure */
  254.   pExtiConfig->Line = hexti->Line;
  255.  
  256.   /* Compute line mask */
  257.   linepos = (pExtiConfig->Line & EXTI_PIN_MASK);
  258.   maskline = (1uL << linepos);
  259.  
  260.   /* 1] Get core mode : interrupt */
  261.  
  262.   /* Check if selected line is enable */
  263.   if ((EXTI->IMR & maskline) != 0x00u)
  264.   {
  265.     pExtiConfig->Mode = EXTI_MODE_INTERRUPT;
  266.   }
  267.   else
  268.   {
  269.     pExtiConfig->Mode = EXTI_MODE_NONE;
  270.   }
  271.  
  272.   /* Get event mode */
  273.   /* Check if selected line is enable */
  274.   if ((EXTI->EMR & maskline) != 0x00u)
  275.   {
  276.     pExtiConfig->Mode |= EXTI_MODE_EVENT;
  277.   }
  278.  
  279.   /* Get default Trigger and GPIOSel configuration */
  280.   pExtiConfig->Trigger = EXTI_TRIGGER_NONE;
  281.   pExtiConfig->GPIOSel = 0x00u;
  282.  
  283.   /* 2] Get trigger for configurable lines : rising */
  284.   if ((pExtiConfig->Line & EXTI_CONFIG) != 0x00u)
  285.   {
  286.     /* Check if configuration of selected line is enable */
  287.     if ((EXTI->RTSR & maskline) != 0x00u)
  288.     {
  289.       pExtiConfig->Trigger = EXTI_TRIGGER_RISING;
  290.     }
  291.  
  292.     /* Get falling configuration */
  293.     /* Check if configuration of selected line is enable */
  294.     if ((EXTI->FTSR & maskline) != 0x00u)
  295.     {
  296.       pExtiConfig->Trigger |= EXTI_TRIGGER_FALLING;
  297.     }
  298.  
  299.     /* Get Gpio port selection for gpio lines */
  300.     if ((pExtiConfig->Line & EXTI_GPIO) == EXTI_GPIO)
  301.     {
  302.       assert_param(IS_EXTI_GPIO_PIN(linepos));
  303.  
  304.       regval = AFIO->EXTICR[linepos >> 2u];
  305.       pExtiConfig->GPIOSel = ((regval << (AFIO_EXTICR1_EXTI1_Pos * (3uL - (linepos & 0x03u)))) >> 24);
  306.     }
  307.   }
  308.  
  309.   return HAL_OK;
  310. }
  311.  
  312. /**
  313.   * @brief  Clear whole configuration of a dedicated Exti line.
  314.   * @param  hexti Exti handle.
  315.   * @retval HAL Status.
  316.   */
  317. HAL_StatusTypeDef HAL_EXTI_ClearConfigLine(EXTI_HandleTypeDef *hexti)
  318. {
  319.   uint32_t regval;
  320.   uint32_t linepos;
  321.   uint32_t maskline;
  322.  
  323.   /* Check null pointer */
  324.   if (hexti == NULL)
  325.   {
  326.     return HAL_ERROR;
  327.   }
  328.  
  329.   /* Check the parameter */
  330.   assert_param(IS_EXTI_LINE(hexti->Line));
  331.  
  332.   /* compute line mask */
  333.   linepos = (hexti->Line & EXTI_PIN_MASK);
  334.   maskline = (1uL << linepos);
  335.  
  336.   /* 1] Clear interrupt mode */
  337.   EXTI->IMR = (EXTI->IMR & ~maskline);
  338.  
  339.   /* 2] Clear event mode */
  340.   EXTI->EMR = (EXTI->EMR & ~maskline);
  341.  
  342.   /* 3] Clear triggers in case of configurable lines */
  343.   if ((hexti->Line & EXTI_CONFIG) != 0x00u)
  344.   {
  345.     EXTI->RTSR = (EXTI->RTSR & ~maskline);
  346.     EXTI->FTSR = (EXTI->FTSR & ~maskline);
  347.  
  348.     /* Get Gpio port selection for gpio lines */
  349.     if ((hexti->Line & EXTI_GPIO) == EXTI_GPIO)
  350.     {
  351.       assert_param(IS_EXTI_GPIO_PIN(linepos));
  352.  
  353.       regval = AFIO->EXTICR[linepos >> 2u];
  354.       regval &= ~(AFIO_EXTICR1_EXTI0 << (AFIO_EXTICR1_EXTI1_Pos * (linepos & 0x03u)));
  355.       AFIO->EXTICR[linepos >> 2u] = regval;
  356.     }
  357.   }
  358.  
  359.   return HAL_OK;
  360. }
  361.  
  362. /**
  363.   * @brief  Register callback for a dedicated Exti line.
  364.   * @param  hexti Exti handle.
  365.   * @param  CallbackID User callback identifier.
  366.   *         This parameter can be one of @arg @ref EXTI_CallbackIDTypeDef values.
  367.   * @param  pPendingCbfn function pointer to be stored as callback.
  368.   * @retval HAL Status.
  369.   */
  370. HAL_StatusTypeDef HAL_EXTI_RegisterCallback(EXTI_HandleTypeDef *hexti, EXTI_CallbackIDTypeDef CallbackID, void (*pPendingCbfn)(void))
  371. {
  372.   HAL_StatusTypeDef status = HAL_OK;
  373.  
  374.   switch (CallbackID)
  375.   {
  376.     case  HAL_EXTI_COMMON_CB_ID:
  377.       hexti->PendingCallback = pPendingCbfn;
  378.       break;
  379.  
  380.     default:
  381.       status = HAL_ERROR;
  382.       break;
  383.   }
  384.  
  385.   return status;
  386. }
  387.  
  388. /**
  389.   * @brief  Store line number as handle private field.
  390.   * @param  hexti Exti handle.
  391.   * @param  ExtiLine Exti line number.
  392.   *         This parameter can be from 0 to @ref EXTI_LINE_NB.
  393.   * @retval HAL Status.
  394.   */
  395. HAL_StatusTypeDef HAL_EXTI_GetHandle(EXTI_HandleTypeDef *hexti, uint32_t ExtiLine)
  396. {
  397.   /* Check the parameters */
  398.   assert_param(IS_EXTI_LINE(ExtiLine));
  399.  
  400.   /* Check null pointer */
  401.   if (hexti == NULL)
  402.   {
  403.     return HAL_ERROR;
  404.   }
  405.   else
  406.   {
  407.     /* Store line number as handle private field */
  408.     hexti->Line = ExtiLine;
  409.  
  410.     return HAL_OK;
  411.   }
  412. }
  413.  
  414. /**
  415.   * @}
  416.   */
  417.  
  418. /** @addtogroup EXTI_Exported_Functions_Group2
  419.   *  @brief EXTI IO functions.
  420.   *
  421. @verbatim
  422.  ===============================================================================
  423.                        ##### IO operation functions #####
  424.  ===============================================================================
  425.  
  426. @endverbatim
  427.   * @{
  428.   */
  429.  
  430. /**
  431.   * @brief  Handle EXTI interrupt request.
  432.   * @param  hexti Exti handle.
  433.   * @retval none.
  434.   */
  435. void HAL_EXTI_IRQHandler(EXTI_HandleTypeDef *hexti)
  436. {
  437.   uint32_t regval;
  438.   uint32_t maskline;
  439.  
  440.   /* Compute line mask */
  441.   maskline = (1uL << (hexti->Line & EXTI_PIN_MASK));
  442.  
  443.   /* Get pending bit  */
  444.   regval = (EXTI->PR & maskline);
  445.   if (regval != 0x00u)
  446.   {
  447.     /* Clear pending bit */
  448.     EXTI->PR = maskline;
  449.  
  450.     /* Call callback */
  451.     if (hexti->PendingCallback != NULL)
  452.     {
  453.       hexti->PendingCallback();
  454.     }
  455.   }
  456. }
  457.  
  458. /**
  459.   * @brief  Get interrupt pending bit of a dedicated line.
  460.   * @param  hexti Exti handle.
  461.   * @param  Edge Specify which pending edge as to be checked.
  462.   *         This parameter can be one of the following values:
  463.   *           @arg @ref EXTI_TRIGGER_RISING_FALLING
  464.   *         This parameter is kept for compatibility with other series.
  465.   * @retval 1 if interrupt is pending else 0.
  466.   */
  467. uint32_t HAL_EXTI_GetPending(EXTI_HandleTypeDef *hexti, uint32_t Edge)
  468. {
  469.   uint32_t regval;
  470.   uint32_t maskline;
  471.   uint32_t linepos;
  472.  
  473.   /* Check parameters */
  474.   assert_param(IS_EXTI_LINE(hexti->Line));
  475.   assert_param(IS_EXTI_CONFIG_LINE(hexti->Line));
  476.   assert_param(IS_EXTI_PENDING_EDGE(Edge));
  477.  
  478.   /* Prevent unused argument compilation warning */
  479.   UNUSED(Edge);
  480.  
  481.   /* Compute line mask */
  482.   linepos = (hexti->Line & EXTI_PIN_MASK);
  483.   maskline = (1uL << linepos);
  484.  
  485.   /* return 1 if bit is set else 0 */
  486.   regval = ((EXTI->PR & maskline) >> linepos);
  487.   return regval;
  488. }
  489.  
  490. /**
  491.   * @brief  Clear interrupt pending bit of a dedicated line.
  492.   * @param  hexti Exti handle.
  493.   * @param  Edge Specify which pending edge as to be clear.
  494.   *         This parameter can be one of the following values:
  495.   *           @arg @ref EXTI_TRIGGER_RISING_FALLING
  496.   *         This parameter is kept for compatibility with other series.
  497.   * @retval None.
  498.   */
  499. void HAL_EXTI_ClearPending(EXTI_HandleTypeDef *hexti, uint32_t Edge)
  500. {
  501.   uint32_t maskline;
  502.  
  503.   /* Check parameters */
  504.   assert_param(IS_EXTI_LINE(hexti->Line));
  505.   assert_param(IS_EXTI_CONFIG_LINE(hexti->Line));
  506.   assert_param(IS_EXTI_PENDING_EDGE(Edge));
  507.  
  508.   /* Prevent unused argument compilation warning */
  509.   UNUSED(Edge);
  510.  
  511.   /* Compute line mask */
  512.   maskline = (1uL << (hexti->Line & EXTI_PIN_MASK));
  513.  
  514.   /* Clear Pending bit */
  515.   EXTI->PR =  maskline;
  516. }
  517.  
  518. /**
  519.   * @brief  Generate a software interrupt for a dedicated line.
  520.   * @param  hexti Exti handle.
  521.   * @retval None.
  522.   */
  523. void HAL_EXTI_GenerateSWI(EXTI_HandleTypeDef *hexti)
  524. {
  525.   uint32_t maskline;
  526.  
  527.   /* Check parameters */
  528.   assert_param(IS_EXTI_LINE(hexti->Line));
  529.   assert_param(IS_EXTI_CONFIG_LINE(hexti->Line));
  530.  
  531.   /* Compute line mask */
  532.   maskline = (1uL << (hexti->Line & EXTI_PIN_MASK));
  533.  
  534.   /* Generate Software interrupt */
  535.   EXTI->SWIER = maskline;
  536. }
  537.  
  538. /**
  539.   * @}
  540.   */
  541.  
  542. /**
  543.   * @}
  544.   */
  545.  
  546. #endif /* HAL_EXTI_MODULE_ENABLED */
  547. /**
  548.   * @}
  549.   */
  550.  
  551. /**
  552.   * @}
  553.   */
  554.  
  555. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  556.