Subversion Repositories DashDisplay

Rev

Rev 2 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /**
  2.   ******************************************************************************
  3.   * @file    stm32f1xx_hal_dac_ex.c
  4.   * @author  MCD Application Team
  5.   * @version V1.0.4
  6.   * @date    29-April-2016
  7.   * @brief   DAC HAL module driver.
  8.   *         This file provides firmware functions to manage the following
  9.   *         functionalities of DAC extension peripheral:
  10.   *           + Extended features functions
  11.   *    
  12.   *
  13.   @verbatim      
  14.   ==============================================================================
  15.                       ##### How to use this driver #####
  16.   ==============================================================================
  17.     [..]          
  18.       (+) When Dual mode is enabled (i.e DAC Channel1 and Channel2 are used simultaneously) :
  19.           Use HAL_DACEx_DualGetValue() to get digital data to be converted and use
  20.           HAL_DACEx_DualSetValue() to set digital value to converted simultaneously in Channel 1 and Channel 2.  
  21.       (+) Use HAL_DACEx_TriangleWaveGenerate() to generate Triangle signal.
  22.       (+) Use HAL_DACEx_NoiseWaveGenerate() to generate Noise signal.
  23.    
  24.  @endverbatim    
  25.   ******************************************************************************
  26.   * @attention
  27.   *
  28.   * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
  29.   *
  30.   * Redistribution and use in source and binary forms, with or without modification,
  31.   * are permitted provided that the following conditions are met:
  32.   *   1. Redistributions of source code must retain the above copyright notice,
  33.   *      this list of conditions and the following disclaimer.
  34.   *   2. Redistributions in binary form must reproduce the above copyright notice,
  35.   *      this list of conditions and the following disclaimer in the documentation
  36.   *      and/or other materials provided with the distribution.
  37.   *   3. Neither the name of STMicroelectronics nor the names of its contributors
  38.   *      may be used to endorse or promote products derived from this software
  39.   *      without specific prior written permission.
  40.   *
  41.   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  42.   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43.   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  44.   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  45.   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46.   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  47.   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  48.   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  49.   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  50.   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  51.   *
  52.   ******************************************************************************
  53.   */
  54.  
  55.  
  56. /* Includes ------------------------------------------------------------------*/
  57. #include "stm32f1xx_hal.h"
  58.  
  59. /** @addtogroup STM32F1xx_HAL_Driver
  60.   * @{
  61.   */
  62.  
  63. /** @defgroup DACEx DACEx
  64.   * @brief DACEx driver module
  65.   * @{
  66.   */
  67.  
  68. #ifdef HAL_DAC_MODULE_ENABLED
  69. #if defined (STM32F100xB) || defined (STM32F100xE) || defined (STM32F101xE) || defined (STM32F101xG) || defined (STM32F103xE) || defined (STM32F103xG) || defined (STM32F105xC) || defined (STM32F107xC)
  70.  
  71. /* Private typedef -----------------------------------------------------------*/
  72. /* Private define ------------------------------------------------------------*/
  73. /* Private macro -------------------------------------------------------------*/
  74. /* Private variables ---------------------------------------------------------*/
  75. /* Private function prototypes -----------------------------------------------*/
  76. /* Exported functions --------------------------------------------------------*/
  77.  
  78. /** @defgroup DACEx_Exported_Functions DACEx Exported Functions
  79.   * @{
  80.   */
  81.  
  82. /** @defgroup DACEx_Exported_Functions_Group1 Extended features functions
  83.  *  @brief    Extended features functions
  84.  *
  85. @verbatim  
  86.   ==============================================================================
  87.                  ##### Extended features functions #####
  88.   ==============================================================================  
  89.     [..]  This section provides functions allowing to:
  90.       (+) Start conversion.
  91.       (+) Stop conversion.
  92.       (+) Start conversion and enable DMA transfer.
  93.       (+) Stop conversion and disable DMA transfer.
  94.       (+) Get result of conversion.
  95.       (+) Get result of dual mode conversion.
  96.                      
  97. @endverbatim
  98.   * @{
  99.   */
  100.  
  101. /**
  102.   * @brief  Returns the last data output value of the selected DAC channel.
  103.   * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
  104.   *         the configuration information for the specified DAC.
  105.   * @retval The selected DAC channel data output value.
  106.   */
  107. uint32_t HAL_DACEx_DualGetValue(DAC_HandleTypeDef* hdac)
  108. {
  109.   uint32_t tmp = 0;
  110.  
  111.   tmp |= hdac->Instance->DOR1;
  112.  
  113.   tmp |= hdac->Instance->DOR2 << 16;
  114.  
  115.   /* Returns the DAC channel data output register value */
  116.   return tmp;
  117. }
  118.  
  119. /**
  120.   * @brief  Enables or disables the selected DAC channel wave generation.
  121.   * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
  122.   *         the configuration information for the specified DAC.
  123.   * @param  Channel: The selected DAC channel.
  124.   *          This parameter can be one of the following values:
  125.   *            DAC_CHANNEL_1 / DAC_CHANNEL_2
  126.   * @param  Amplitude: Select max triangle amplitude.
  127.   *          This parameter can be one of the following values:
  128.   *            @arg DAC_TRIANGLEAMPLITUDE_1: Select max triangle amplitude of 1
  129.   *            @arg DAC_TRIANGLEAMPLITUDE_3: Select max triangle amplitude of 3
  130.   *            @arg DAC_TRIANGLEAMPLITUDE_7: Select max triangle amplitude of 7
  131.   *            @arg DAC_TRIANGLEAMPLITUDE_15: Select max triangle amplitude of 15
  132.   *            @arg DAC_TRIANGLEAMPLITUDE_31: Select max triangle amplitude of 31
  133.   *            @arg DAC_TRIANGLEAMPLITUDE_63: Select max triangle amplitude of 63
  134.   *            @arg DAC_TRIANGLEAMPLITUDE_127: Select max triangle amplitude of 127
  135.   *            @arg DAC_TRIANGLEAMPLITUDE_255: Select max triangle amplitude of 255
  136.   *            @arg DAC_TRIANGLEAMPLITUDE_511: Select max triangle amplitude of 511
  137.   *            @arg DAC_TRIANGLEAMPLITUDE_1023: Select max triangle amplitude of 1023
  138.   *            @arg DAC_TRIANGLEAMPLITUDE_2047: Select max triangle amplitude of 2047
  139.   *            @arg DAC_TRIANGLEAMPLITUDE_4095: Select max triangle amplitude of 4095                              
  140.   * @retval HAL status
  141.   */
  142. HAL_StatusTypeDef HAL_DACEx_TriangleWaveGenerate(DAC_HandleTypeDef* hdac, uint32_t Channel, uint32_t Amplitude)
  143. {  
  144.   /* Check the parameters */
  145.   assert_param(IS_DAC_CHANNEL(Channel));
  146.   assert_param(IS_DAC_LFSR_UNMASK_TRIANGLE_AMPLITUDE(Amplitude));
  147.  
  148.   /* Process locked */
  149.   __HAL_LOCK(hdac);
  150.  
  151.   /* Change DAC state */
  152.   hdac->State = HAL_DAC_STATE_BUSY;
  153.  
  154.   /* Enable the selected wave generation for the selected DAC channel */
  155.   MODIFY_REG(hdac->Instance->CR, ((DAC_CR_WAVE1)|(DAC_CR_MAMP1))<<Channel, (DAC_CR_WAVE1_1 | Amplitude) << Channel);
  156.  
  157.   /* Change DAC state */
  158.   hdac->State = HAL_DAC_STATE_READY;
  159.  
  160.   /* Process unlocked */
  161.   __HAL_UNLOCK(hdac);
  162.  
  163.   /* Return function status */
  164.   return HAL_OK;
  165. }
  166.  
  167. /**
  168.   * @brief  Enables or disables the selected DAC channel wave generation.
  169.   * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
  170.   *         the configuration information for the specified DAC.
  171.   * @param  Channel: The selected DAC channel.
  172.   *          This parameter can be one of the following values:
  173.   *            DAC_CHANNEL_1 / DAC_CHANNEL_2
  174.   * @param  Amplitude: Unmask DAC channel LFSR for noise wave generation.
  175.   *          This parameter can be one of the following values:
  176.   *            @arg DAC_LFSRUNMASK_BIT0: Unmask DAC channel LFSR bit0 for noise wave generation
  177.   *            @arg DAC_LFSRUNMASK_BITS1_0: Unmask DAC channel LFSR bit[1:0] for noise wave generation  
  178.   *            @arg DAC_LFSRUNMASK_BITS2_0: Unmask DAC channel LFSR bit[2:0] for noise wave generation
  179.   *            @arg DAC_LFSRUNMASK_BITS3_0: Unmask DAC channel LFSR bit[3:0] for noise wave generation
  180.   *            @arg DAC_LFSRUNMASK_BITS4_0: Unmask DAC channel LFSR bit[4:0] for noise wave generation
  181.   *            @arg DAC_LFSRUNMASK_BITS5_0: Unmask DAC channel LFSR bit[5:0] for noise wave generation
  182.   *            @arg DAC_LFSRUNMASK_BITS6_0: Unmask DAC channel LFSR bit[6:0] for noise wave generation
  183.   *            @arg DAC_LFSRUNMASK_BITS7_0: Unmask DAC channel LFSR bit[7:0] for noise wave generation
  184.   *            @arg DAC_LFSRUNMASK_BITS8_0: Unmask DAC channel LFSR bit[8:0] for noise wave generation
  185.   *            @arg DAC_LFSRUNMASK_BITS9_0: Unmask DAC channel LFSR bit[9:0] for noise wave generation
  186.   *            @arg DAC_LFSRUNMASK_BITS10_0: Unmask DAC channel LFSR bit[10:0] for noise wave generation
  187.   *            @arg DAC_LFSRUNMASK_BITS11_0: Unmask DAC channel LFSR bit[11:0] for noise wave generation
  188.   * @retval HAL status
  189.   */
  190. HAL_StatusTypeDef HAL_DACEx_NoiseWaveGenerate(DAC_HandleTypeDef* hdac, uint32_t Channel, uint32_t Amplitude)
  191. {  
  192.   /* Check the parameters */
  193.   assert_param(IS_DAC_CHANNEL(Channel));
  194.   assert_param(IS_DAC_LFSR_UNMASK_TRIANGLE_AMPLITUDE(Amplitude));
  195.  
  196.   /* Process locked */
  197.   __HAL_LOCK(hdac);
  198.  
  199.   /* Change DAC state */
  200.   hdac->State = HAL_DAC_STATE_BUSY;
  201.  
  202.   /* Enable the selected wave generation for the selected DAC channel */
  203.   MODIFY_REG(hdac->Instance->CR, ((DAC_CR_WAVE1)|(DAC_CR_MAMP1))<<Channel, (DAC_CR_WAVE1_0 | Amplitude) << Channel);
  204.  
  205.   /* Change DAC state */
  206.   hdac->State = HAL_DAC_STATE_READY;
  207.  
  208.   /* Process unlocked */
  209.   __HAL_UNLOCK(hdac);
  210.  
  211.   /* Return function status */
  212.   return HAL_OK;
  213. }
  214.  
  215. /**
  216.   * @brief  Set the specified data holding register value for dual DAC channel.
  217.   * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
  218.   *               the configuration information for the specified DAC.
  219.   * @param  Alignment: Specifies the data alignment for dual channel DAC.
  220.   *          This parameter can be one of the following values:
  221.   *            DAC_ALIGN_8B_R: 8bit right data alignment selected
  222.   *            DAC_ALIGN_12B_L: 12bit left data alignment selected
  223.   *            DAC_ALIGN_12B_R: 12bit right data alignment selected
  224.   * @param  Data1: Data for DAC Channel2 to be loaded in the selected data holding register.
  225.   * @param  Data2: Data for DAC Channel1 to be loaded in the selected data  holding register.
  226.   * @note   In dual mode, a unique register access is required to write in both
  227.   *          DAC channels at the same time.
  228.   * @retval HAL status
  229.   */
  230. HAL_StatusTypeDef HAL_DACEx_DualSetValue(DAC_HandleTypeDef* hdac, uint32_t Alignment, uint32_t Data1, uint32_t Data2)
  231. {  
  232.   uint32_t data = 0, tmp = 0;
  233.  
  234.   /* Check the parameters */
  235.   assert_param(IS_DAC_ALIGN(Alignment));
  236.   assert_param(IS_DAC_DATA(Data1));
  237.   assert_param(IS_DAC_DATA(Data2));
  238.  
  239.   /* Calculate and set dual DAC data holding register value */
  240.   if (Alignment == DAC_ALIGN_8B_R)
  241.   {
  242.     data = ((uint32_t)Data2 << 8) | Data1;
  243.   }
  244.   else
  245.   {
  246.     data = ((uint32_t)Data2 << 16) | Data1;
  247.   }
  248.  
  249.   tmp = (uint32_t)hdac->Instance;
  250.   tmp += DAC_DHR12RD_ALIGNMENT(Alignment);
  251.  
  252.   /* Set the dual DAC selected data holding register */
  253.   *(__IO uint32_t *)tmp = data;
  254.  
  255.   /* Return function status */
  256.   return HAL_OK;
  257. }
  258.  
  259. /**
  260.   * @brief  Conversion complete callback in non blocking mode for Channel2
  261.   * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
  262.   *         the configuration information for the specified DAC.
  263.   * @retval None
  264.   */
  265. __weak void HAL_DACEx_ConvCpltCallbackCh2(DAC_HandleTypeDef* hdac)
  266. {
  267.   /* Prevent unused argument(s) compilation warning */
  268.   UNUSED(hdac);
  269.   /* NOTE : This function Should not be modified, when the callback is needed,
  270.             the HAL_DACEx_ConvCpltCallbackCh2 could be implemented in the user file
  271.    */
  272. }
  273.  
  274. /**
  275.   * @brief  Conversion half DMA transfer callback in non blocking mode for Channel2
  276.   * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
  277.   *         the configuration information for the specified DAC.
  278.   * @retval None
  279.   */
  280. __weak void HAL_DACEx_ConvHalfCpltCallbackCh2(DAC_HandleTypeDef* hdac)
  281. {
  282.   /* Prevent unused argument(s) compilation warning */
  283.   UNUSED(hdac);
  284.   /* NOTE : This function Should not be modified, when the callback is needed,
  285.             the HAL_DACEx_ConvHalfCpltCallbackCh2 could be implemented in the user file
  286.    */
  287. }
  288.  
  289. /**
  290.   * @brief  Error DAC callback for Channel2.
  291.   * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
  292.   *         the configuration information for the specified DAC.
  293.   * @retval None
  294.   */
  295. __weak void HAL_DACEx_ErrorCallbackCh2(DAC_HandleTypeDef *hdac)
  296. {
  297.   /* Prevent unused argument(s) compilation warning */
  298.   UNUSED(hdac);
  299.   /* NOTE : This function Should not be modified, when the callback is needed,
  300.             the HAL_DACEx_ErrorCallbackCh2 could be implemented in the user file
  301.    */
  302. }
  303.  
  304. #if defined (STM32F100xB) || defined (STM32F100xE)
  305. /**
  306.   * @brief  DMA underrun DAC callback for channel1.
  307.   *         Note: For STM32F100x devices with specific feature: DMA underrun.
  308.   *         On these devices, this function uses the interruption of DMA
  309.   *         underrun.
  310.   * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
  311.   *         the configuration information for the specified DAC.
  312.   * @retval None
  313.   */
  314. __weak void HAL_DAC_DMAUnderrunCallbackCh1(DAC_HandleTypeDef *hdac)
  315. {
  316.   /* Prevent unused argument(s) compilation warning */
  317.   UNUSED(hdac);
  318.   /* NOTE : This function Should not be modified, when the callback is needed,
  319.             the HAL_DAC_DMAUnderrunCallbackCh1 could be implemented in the user file
  320.    */
  321. }
  322.  
  323. /**
  324.   * @brief  DMA underrun DAC callback for channel2.
  325.   *         Note: For STM32F100x devices with specific feature: DMA underrun.
  326.   *         On these devices, this function uses the interruption of DMA
  327.   *         underrun.
  328.   * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
  329.   *         the configuration information for the specified DAC.
  330.   * @retval None
  331.   */
  332. __weak void HAL_DACEx_DMAUnderrunCallbackCh2(DAC_HandleTypeDef *hdac)
  333. {
  334.   /* Prevent unused argument(s) compilation warning */
  335.   UNUSED(hdac);
  336.   /* NOTE : This function Should not be modified, when the callback is needed,
  337.             the HAL_DACEx_DMAUnderrunCallbackCh2 could be implemented in the user file
  338.    */
  339. }
  340. #endif /* STM32F100xB) || defined (STM32F100xE) */
  341.  
  342. /**
  343.   * @}
  344.   */
  345.  
  346. #if defined (STM32F100xB) || defined (STM32F100xE)
  347. /**
  348.   * @brief  Enables DAC and starts conversion of channel.
  349.   *         Note: For STM32F100x devices with specific feature: DMA underrun.
  350.   *         On these devices, this function enables the interruption of DMA
  351.   *         underrun.
  352.   * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
  353.   *         the configuration information for the specified DAC.
  354.   * @param  Channel: The selected DAC channel.
  355.   *          This parameter can be one of the following values:
  356.   *            @arg DAC_CHANNEL_1: DAC Channel1 selected
  357.   *            @arg DAC_CHANNEL_2: DAC Channel2 selected
  358.   * @param  pData: The destination peripheral Buffer address.
  359.   * @param  Length: The length of data to be transferred from memory to DAC peripheral
  360.   * @param  Alignment: Specifies the data alignment for DAC channel.
  361.   *          This parameter can be one of the following values:
  362.   *            @arg DAC_ALIGN_8B_R: 8bit right data alignment selected
  363.   *            @arg DAC_ALIGN_12B_L: 12bit left data alignment selected
  364.   *            @arg DAC_ALIGN_12B_R: 12bit right data alignment selected
  365.   * @retval HAL status
  366.   */
  367. HAL_StatusTypeDef HAL_DAC_Start_DMA(DAC_HandleTypeDef* hdac, uint32_t Channel, uint32_t* pData, uint32_t Length, uint32_t Alignment)
  368. {
  369.   uint32_t tmpreg = 0;
  370.    
  371.   /* Check the parameters */
  372.   assert_param(IS_DAC_CHANNEL(Channel));
  373.   assert_param(IS_DAC_ALIGN(Alignment));
  374.  
  375.   /* Process locked */
  376.   __HAL_LOCK(hdac);
  377.  
  378.   /* Change DAC state */
  379.   hdac->State = HAL_DAC_STATE_BUSY;
  380.  
  381.   if(Channel == DAC_CHANNEL_1)
  382.   {
  383.     /* Set the DMA transfer complete callback for channel1 */
  384.     hdac->DMA_Handle1->XferCpltCallback = DAC_DMAConvCpltCh1;
  385.  
  386.     /* Set the DMA half transfer complete callback for channel1 */
  387.     hdac->DMA_Handle1->XferHalfCpltCallback = DAC_DMAHalfConvCpltCh1;
  388.  
  389.     /* Set the DMA error callback for channel1 */
  390.     hdac->DMA_Handle1->XferErrorCallback = DAC_DMAErrorCh1;
  391.  
  392.     /* Enable the selected DAC channel1 DMA request */
  393.     SET_BIT(hdac->Instance->CR, DAC_CR_DMAEN1);
  394.        
  395.     /* Case of use of channel 1 */
  396.     switch(Alignment)
  397.     {
  398.       case DAC_ALIGN_12B_R:
  399.         /* Get DHR12R1 address */
  400.         tmpreg = (uint32_t)&hdac->Instance->DHR12R1;
  401.         break;
  402.       case DAC_ALIGN_12B_L:
  403.         /* Get DHR12L1 address */
  404.         tmpreg = (uint32_t)&hdac->Instance->DHR12L1;
  405.         break;
  406.       case DAC_ALIGN_8B_R:
  407.         /* Get DHR8R1 address */
  408.         tmpreg = (uint32_t)&hdac->Instance->DHR8R1;
  409.         break;
  410.       default:
  411.         break;
  412.     }
  413.   }
  414.   else
  415.   {
  416.     /* Set the DMA transfer complete callback for channel2 */
  417.     hdac->DMA_Handle2->XferCpltCallback = DAC_DMAConvCpltCh2;
  418.  
  419.     /* Set the DMA half transfer complete callback for channel2 */
  420.     hdac->DMA_Handle2->XferHalfCpltCallback = DAC_DMAHalfConvCpltCh2;
  421.    
  422.     /* Set the DMA error callback for channel2 */
  423.     hdac->DMA_Handle2->XferErrorCallback = DAC_DMAErrorCh2;
  424.  
  425.     /* Enable the selected DAC channel2 DMA request */
  426.     SET_BIT(hdac->Instance->CR, DAC_CR_DMAEN2);
  427.  
  428.     /* Case of use of channel 2 */
  429.     switch(Alignment)
  430.     {
  431.       case DAC_ALIGN_12B_R:
  432.         /* Get DHR12R2 address */
  433.         tmpreg = (uint32_t)&hdac->Instance->DHR12R2;
  434.         break;
  435.       case DAC_ALIGN_12B_L:
  436.         /* Get DHR12L2 address */
  437.         tmpreg = (uint32_t)&hdac->Instance->DHR12L2;
  438.         break;
  439.       case DAC_ALIGN_8B_R:
  440.         /* Get DHR8R2 address */
  441.         tmpreg = (uint32_t)&hdac->Instance->DHR8R2;
  442.         break;
  443.       default:
  444.         break;
  445.     }
  446.   }
  447.  
  448.   /* Enable the DMA channel */
  449.   if(Channel == DAC_CHANNEL_1)
  450.   {
  451.     /* Enable the DAC DMA underrun interrupt */
  452.     __HAL_DAC_ENABLE_IT(hdac, DAC_IT_DMAUDR1);
  453.    
  454.     /* Enable the DMA channel */
  455.     HAL_DMA_Start_IT(hdac->DMA_Handle1, (uint32_t)pData, tmpreg, Length);
  456.   }
  457.   else
  458.   {
  459.     /* Enable the DAC DMA underrun interrupt */
  460.     __HAL_DAC_ENABLE_IT(hdac, DAC_IT_DMAUDR2);
  461.    
  462.     /* Enable the DMA channel */
  463.     HAL_DMA_Start_IT(hdac->DMA_Handle2, (uint32_t)pData, tmpreg, Length);
  464.   }
  465.  
  466.   /* Enable the Peripharal */
  467.   __HAL_DAC_ENABLE(hdac, Channel);
  468.  
  469.   /* Process Unlocked */
  470.   __HAL_UNLOCK(hdac);
  471.  
  472.   /* Return function status */
  473.   return HAL_OK;
  474. }
  475. #endif /* STM32F100xB) || defined (STM32F100xE) */
  476.  
  477. #if defined (STM32F100xB) || defined (STM32F100xE)
  478. /**
  479.   * @brief  Disables DAC and stop conversion of channel.
  480.   *         Note: For STM32F100x devices with specific feature: DMA underrun.
  481.   *         On these devices, this function disables the interruption of DMA
  482.   *         underrun.
  483.   * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
  484.   *         the configuration information for the specified DAC.
  485.   * @param  Channel: The selected DAC channel.
  486.   *          This parameter can be one of the following values:
  487.   *            @arg DAC_CHANNEL_1: DAC Channel1 selected
  488.   *            @arg DAC_CHANNEL_2: DAC Channel2 selected  
  489.   * @retval HAL status
  490.   */
  491. HAL_StatusTypeDef HAL_DAC_Stop_DMA(DAC_HandleTypeDef* hdac, uint32_t Channel)
  492. {
  493.   HAL_StatusTypeDef status = HAL_OK;
  494.  
  495.   /* Check the parameters */
  496.   assert_param(IS_DAC_CHANNEL(Channel));
  497.  
  498.   /* Disable the selected DAC channel DMA request */
  499.   hdac->Instance->CR &= ~(DAC_CR_DMAEN1 << Channel);
  500.    
  501.   /* Disable the Peripharal */
  502.   __HAL_DAC_DISABLE(hdac, Channel);
  503.  
  504.   /* Disable the DMA Channel */
  505.   /* Channel1 is used */
  506.   if(Channel == DAC_CHANNEL_1)
  507.   {
  508.     /* Disable the DMA channel */
  509.     status = HAL_DMA_Abort(hdac->DMA_Handle1);
  510.    
  511.     /* Disable the DAC DMA underrun interrupt */
  512.     __HAL_DAC_DISABLE_IT(hdac, DAC_IT_DMAUDR1);
  513.   }
  514.   else /* Channel2 is used for */
  515.   {
  516.     /* Disable the DMA channel */
  517.     status = HAL_DMA_Abort(hdac->DMA_Handle2);
  518.    
  519.     /* Disable the DAC DMA underrun interrupt */
  520.     __HAL_DAC_DISABLE_IT(hdac, DAC_IT_DMAUDR2);
  521.   }
  522.  
  523.   /* Check if DMA Channel effectively disabled */
  524.   if(status != HAL_OK)
  525.   {
  526.     /* Update ADC state machine to error */
  527.     hdac->State = HAL_DAC_STATE_ERROR;      
  528.   }
  529.   else
  530.   {
  531.     /* Change DAC state */
  532.     hdac->State = HAL_DAC_STATE_READY;
  533.   }
  534.  
  535.   /* Return function status */
  536.   return status;
  537. }
  538. #endif /* STM32F100xB) || defined (STM32F100xE) */
  539.  
  540. #if defined (STM32F100xB) || defined (STM32F100xE)
  541. /**
  542.   * @brief  Handles DAC interrupt request
  543.   *         Note: For STM32F100x devices with specific feature: DMA underrun.
  544.   *         On these devices, this function uses the interruption of DMA
  545.   *         underrun.
  546.   * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
  547.   *         the configuration information for the specified DAC.
  548.   * @retval None
  549.   */
  550. void HAL_DAC_IRQHandler(DAC_HandleTypeDef* hdac)
  551. {
  552.  
  553.   if(__HAL_DAC_GET_IT_SOURCE(hdac, DAC_IT_DMAUDR1))
  554.   {
  555.     /* Check underrun flag of DAC channel 1 */
  556.     if(__HAL_DAC_GET_FLAG(hdac, DAC_FLAG_DMAUDR1))
  557.     {
  558.       /* Change DAC state to error state */
  559.       hdac->State = HAL_DAC_STATE_ERROR;
  560.      
  561.       /* Set DAC error code to chanel1 DMA underrun error */
  562.       SET_BIT(hdac->ErrorCode, HAL_DAC_ERROR_DMAUNDERRUNCH1);
  563.      
  564.       /* Clear the underrun flag */
  565.       __HAL_DAC_CLEAR_FLAG(hdac,DAC_FLAG_DMAUDR1);
  566.      
  567.       /* Disable the selected DAC channel1 DMA request */
  568.       CLEAR_BIT(hdac->Instance->CR, DAC_CR_DMAEN1);
  569.      
  570.       /* Error callback */
  571.       HAL_DAC_DMAUnderrunCallbackCh1(hdac);
  572.     }
  573.   }
  574.  
  575.   if(__HAL_DAC_GET_IT_SOURCE(hdac, DAC_IT_DMAUDR2))
  576.   {
  577.     /* Check underrun flag of DAC channel 2 */
  578.     if(__HAL_DAC_GET_FLAG(hdac, DAC_FLAG_DMAUDR2))
  579.     {
  580.       /* Change DAC state to error state */
  581.       hdac->State = HAL_DAC_STATE_ERROR;
  582.      
  583.       /* Set DAC error code to channel2 DMA underrun error */
  584.       SET_BIT(hdac->ErrorCode, HAL_DAC_ERROR_DMAUNDERRUNCH2);
  585.      
  586.       /* Clear the underrun flag */
  587.       __HAL_DAC_CLEAR_FLAG(hdac,DAC_FLAG_DMAUDR2);
  588.      
  589.       /* Disable the selected DAC channel1 DMA request */
  590.       CLEAR_BIT(hdac->Instance->CR, DAC_CR_DMAEN2);
  591.      
  592.       /* Error callback */
  593.       HAL_DACEx_DMAUnderrunCallbackCh2(hdac);
  594.     }
  595.   }
  596. }
  597. #endif /* STM32F100xB || STM32F100xE */
  598.  
  599.  
  600. /**
  601.   * @}
  602.   */
  603.  
  604. /** @defgroup DACEx_Private_Functions DACEx Private Functions
  605.   * @{
  606.   */
  607.  
  608. /**
  609.   * @brief  DMA conversion complete callback.
  610.   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
  611.   *                the configuration information for the specified DMA module.
  612.   * @retval None
  613.   */
  614. void DAC_DMAConvCpltCh2(DMA_HandleTypeDef *hdma)  
  615. {
  616.   DAC_HandleTypeDef* hdac = ( DAC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
  617.  
  618.   HAL_DACEx_ConvCpltCallbackCh2(hdac);
  619.  
  620.   hdac->State= HAL_DAC_STATE_READY;
  621. }
  622.  
  623. /**
  624.   * @brief  DMA half transfer complete callback.
  625.   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
  626.   *                the configuration information for the specified DMA module.
  627.   * @retval None
  628.   */
  629. void DAC_DMAHalfConvCpltCh2(DMA_HandleTypeDef *hdma)  
  630. {
  631.     DAC_HandleTypeDef* hdac = ( DAC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
  632.     /* Conversion complete callback */
  633.     HAL_DACEx_ConvHalfCpltCallbackCh2(hdac);
  634. }
  635.  
  636. /**
  637.   * @brief  DMA error callback
  638.   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
  639.   *                the configuration information for the specified DMA module.
  640.   * @retval None
  641.   */
  642. void DAC_DMAErrorCh2(DMA_HandleTypeDef *hdma)  
  643. {
  644.   DAC_HandleTypeDef* hdac = ( DAC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
  645.    
  646.   /* Set DAC error code to DMA error */
  647.   hdac->ErrorCode |= HAL_DAC_ERROR_DMA;
  648.    
  649.   HAL_DACEx_ErrorCallbackCh2(hdac);
  650.    
  651.   hdac->State= HAL_DAC_STATE_READY;
  652. }
  653.  
  654. /**
  655.   * @}
  656.   */
  657.  
  658. #endif /* STM32F100xB || STM32F100xE || STM32F101xE || STM32F101xG || STM32F103xE || STM32F103xG || STM32F105xC || STM32F107xC */
  659. #endif /* HAL_DAC_MODULE_ENABLED */
  660.  
  661. /**
  662.   * @}
  663.   */
  664.  
  665. /**
  666.   * @}
  667.   */
  668.  
  669. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  670.