WebSVN – canSerial – Diff – /trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_dac.c

 /**
   ******************************************************************************
   * @file    stm32f1xx_hal_dac.c
   * @author  MCD Application Team
   * @brief   DAC HAL module driver.
   *         This file provides firmware functions to manage the following
   *         functionalities of the Digital to Analog Converter (DAC) peripheral:
   *           + Initialization and de-initialization functions
   *           + IO operation functions
   *           + Peripheral Control functions
   *           + Peripheral State and Errors functions
   *
   *
-  @verbatim
+  ******************************************************************************
-  ==============================================================================
+  * @attention
-                      ##### DAC Peripheral features #####
+  *
-  ==============================================================================
+  * Copyright (c) 2016 STMicroelectronics.
-    [..]
+  * All rights reserved.
-      *** DAC Channels ***
+  *
-      ====================
+  * This software is licensed under terms that can be found in the LICENSE file
-    [..]
+  * in the root directory of this software component.
-    STM32F1 devices integrate two 12-bit Digital Analog Converters
+  * If no LICENSE file comes with this software, it is provided AS-IS.
+  *
-    The 2 converters (i.e. channel1 & channel2)
+  ******************************************************************************
-    can be used independently or simultaneously (dual mode):
+  @verbatim
-      (#) DAC channel1 with DAC_OUT1 (PA4) as output or connected to on-chip
+  ==============================================================================
-          peripherals (ex. timers).
+                      ##### DAC Peripheral features #####
-      (#) DAC channel2 with DAC_OUT2 (PA5) as output or connected to on-chip
+  ==============================================================================
-          peripherals (ex. timers).
+    [..]
+      *** DAC Channels ***
-      *** DAC Triggers ***
+      ====================
-      ====================
+    [..]
-    [..]
+    STM32F1 devices integrate two 12-bit Digital Analog Converters
-    Digital to Analog conversion can be non-triggered using DAC_TRIGGER_NONE
-    and DAC_OUT1/DAC_OUT2 is available once writing to DHRx register.
+    The 2 converters (i.e. channel1 & channel2)
-    [..]
+    can be used independently or simultaneously (dual mode):
-    Digital to Analog conversion can be triggered by:
+      (#) DAC channel1 with DAC_OUT1 (PA4) as output or connected to on-chip
-      (#) External event: EXTI Line 9 (any GPIOx_PIN_9) using DAC_TRIGGER_EXT_IT9.
+          peripherals (ex. timers).
-          The used pin (GPIOx_PIN_9) must be configured in input mode.
+      (#) DAC channel2 with DAC_OUT2 (PA5) as output or connected to on-chip
+          peripherals (ex. timers).
-      (#) Timers TRGO: TIM2, TIM4, TIM6, TIM7
-          For STM32F10x connectivity line devices and STM32F100x devices: TIM3
+      *** DAC Triggers ***
-          For STM32F10x high-density and XL-density devices: TIM8
+      ====================
-          For STM32F100x high-density value line devices: TIM15 as
+    [..]
-          replacement of TIM5.
+    Digital to Analog conversion can be non-triggered using DAC_TRIGGER_NONE
-          (DAC_TRIGGER_T2_TRGO, DAC_TRIGGER_T4_TRGO...)
+    and DAC_OUT1/DAC_OUT2 is available once writing to DHRx register.
+    [..]
-      (#) Software using DAC_TRIGGER_SOFTWARE
+    Digital to Analog conversion can be triggered by:
+      (#) External event: EXTI Line 9 (any GPIOx_PIN_9) using DAC_TRIGGER_EXT_IT9.
-      *** DAC Buffer mode feature ***
+          The used pin (GPIOx_PIN_9) must be configured in input mode.
-      ===============================
-      [..]
+      (#) Timers TRGO: TIM2, TIM4, TIM6, TIM7
-      Each DAC channel integrates an output buffer that can be used to
+          For STM32F10x connectivity line devices and STM32F100x devices: TIM3
-      reduce the output impedance, and to drive external loads directly
+          For STM32F10x high-density and XL-density devices: TIM8
-      without having to add an external operational amplifier.
+          For STM32F100x high-density value line devices: TIM15 as
-      To enable, the output buffer use
+          replacement of TIM5.
-      sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
+          (DAC_TRIGGER_T2_TRGO, DAC_TRIGGER_T4_TRGO...)
-      [..]
-      (@) Refer to the device datasheet for more details about output
+      (#) Software using DAC_TRIGGER_SOFTWARE
-          impedance value with and without output buffer.
+      *** DAC Buffer mode feature ***
-      *** GPIO configurations guidelines ***
+      ===============================
-      =====================
+      [..]
-      [..]
+      Each DAC channel integrates an output buffer that can be used to
-      When a DAC channel is used (ex channel1 on PA4) and the other is not
+      reduce the output impedance, and to drive external loads directly
-      (ex channel2 on PA5 is configured in Analog and disabled).
+      without having to add an external operational amplifier.
-      Channel1 may disturb channel2 as coupling effect.
+      To enable, the output buffer use
-      Note that there is no coupling on channel2 as soon as channel2 is turned on.
+      sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
-      Coupling on adjacent channel could be avoided as follows:
+      [..]
-      when unused PA5 is configured as INPUT PULL-UP or DOWN.
+      (@) Refer to the device datasheet for more details about output
-      PA5 is configured in ANALOG just before it is turned on.
+          impedance value with and without output buffer.
-       *** DAC wave generation feature ***
+      *** GPIO configurations guidelines ***
-       ===================================
+      =====================
-       [..]
+      [..]
-       Both DAC channels can be used to generate
+      When a DAC channel is used (ex channel1 on PA4) and the other is not
-         (#) Noise wave
+      (ex channel2 on PA5 is configured in Analog and disabled).
-         (#) Triangle wave
+      Channel1 may disturb channel2 as coupling effect.
+      Note that there is no coupling on channel2 as soon as channel2 is turned on.
-       *** DAC data format ***
+      Coupling on adjacent channel could be avoided as follows:
-       =======================
+      when unused PA5 is configured as INPUT PULL-UP or DOWN.
-       [..]
+      PA5 is configured in ANALOG just before it is turned on.
-       The DAC data format can be:
-         (#) 8-bit right alignment using DAC_ALIGN_8B_R
+       *** DAC wave generation feature ***
-         (#) 12-bit left alignment using DAC_ALIGN_12B_L
+       ===================================
-         (#) 12-bit right alignment using DAC_ALIGN_12B_R
+       [..]
+       Both DAC channels can be used to generate
-       *** DAC data value to voltage correspondence ***
+         (#) Noise wave
-       ================================================
+         (#) Triangle wave
-       [..]
-       The analog output voltage on each DAC channel pin is determined
+       *** DAC data format ***
-       by the following equation:
+       =======================
        [..]
-       DAC_OUTx = VREF+ * DOR / 4095
+       The DAC data format can be:
-       (+) with  DOR is the Data Output Register
+         (#) 8-bit right alignment using DAC_ALIGN_8B_R
-       [..]
+         (#) 12-bit left alignment using DAC_ALIGN_12B_L
-          VREF+ is the input voltage reference (refer to the device datasheet)
+         (#) 12-bit right alignment using DAC_ALIGN_12B_R
-       [..]
-        e.g. To set DAC_OUT1 to 0.7V, use
+       *** DAC data value to voltage correspondence ***
-       (+) Assuming that VREF+ = 3.3V, DAC_OUT1 = (3.3 * 868) / 4095 = 0.7V
+       ================================================
+       [..]
-       *** DMA requests ***
+       The analog output voltage on each DAC channel pin is determined
-       =====================
+       by the following equation:
        [..]
-       A DMA request can be generated when an external trigger (but not a software trigger)
+       DAC_OUTx = VREF+ * DOR / 4095
-       occurs if DMA1 requests are enabled using HAL_DAC_Start_DMA().
+       (+) with  DOR is the Data Output Register
-       DMA1 requests are mapped as following:
+       [..]
-      (#) DAC channel1 mapped on DMA1 channel3
+          VREF+ is the input voltage reference (refer to the device datasheet)
-          for STM32F100x low-density, medium-density, high-density with DAC
+       [..]
-          DMA remap:
+        e.g. To set DAC_OUT1 to 0.7V, use
-      (#) DAC channel2 mapped on DMA2 channel3
+       (+) Assuming that VREF+ = 3.3V, DAC_OUT1 = (3.3 * 868) / 4095 = 0.7V
-          for STM32F100x high-density without DAC DMA remap and other
-          STM32F1 devices
+       *** DMA requests ***
+       =====================
-     [..]
+       [..]
-    (@) For Dual mode and specific signal (Triangle and noise) generation please
+       A DMA request can be generated when an external trigger (but not a software trigger)
-        refer to Extended Features Driver description
+       occurs if DMA1 requests are enabled using HAL_DAC_Start_DMA().
+       DMA1 requests are mapped as following:
-                      ##### How to use this driver #####
+      (#) DAC channel1 mapped on DMA1 channel3
-  ==============================================================================
+          for STM32F100x low-density, medium-density, high-density with DAC
-    [..]
+          DMA remap:
-      (+) DAC APB clock must be enabled to get write access to DAC
+      (#) DAC channel2 mapped on DMA2 channel3
-          registers using HAL_DAC_Init()
+          for STM32F100x high-density without DAC DMA remap and other
-      (+) Configure DAC_OUTx (DAC_OUT1: PA4, DAC_OUT2: PA5) in analog mode.
+          STM32F1 devices
-      (+) Configure the DAC channel using HAL_DAC_ConfigChannel() function.
-      (+) Enable the DAC channel using HAL_DAC_Start() or HAL_DAC_Start_DMA() functions.
+     [..]
+    (@) For Dual mode and specific signal (Triangle and noise) generation please
+        refer to Extended Features Driver description
-     *** Polling mode IO operation ***
-     =================================
+                      ##### How to use this driver #####
-     [..]
+  ==============================================================================
-       (+) Start the DAC peripheral using HAL_DAC_Start()
+    [..]
-       (+) To read the DAC last data output value, use the HAL_DAC_GetValue() function.
+      (+) DAC APB clock must be enabled to get write access to DAC
-       (+) Stop the DAC peripheral using HAL_DAC_Stop()
+          registers using HAL_DAC_Init()
+      (+) Configure DAC_OUTx (DAC_OUT1: PA4, DAC_OUT2: PA5) in analog mode.
-     *** DMA mode IO operation ***
+      (+) Configure the DAC channel using HAL_DAC_ConfigChannel() function.
-     ==============================
+      (+) Enable the DAC channel using HAL_DAC_Start() or HAL_DAC_Start_DMA() functions.
-     [..]
-       (+) Start the DAC peripheral using HAL_DAC_Start_DMA(), at this stage the user specify the length
-           of data to be transferred at each end of conversion
+     *** Polling mode IO operation ***
-           First issued trigger will start the conversion of the value previously set by HAL_DAC_SetValue().
+     =================================
-       (+) At the middle of data transfer HAL_DAC_ConvHalfCpltCallbackCh1() or HAL_DACEx_ConvHalfCpltCallbackCh2()
+     [..]
-           function is executed and user can add his own code by customization of function pointer
+       (+) Start the DAC peripheral using HAL_DAC_Start()
-           HAL_DAC_ConvHalfCpltCallbackCh1() or HAL_DACEx_ConvHalfCpltCallbackCh2()
+       (+) To read the DAC last data output value, use the HAL_DAC_GetValue() function.
-       (+) At The end of data transfer HAL_DAC_ConvCpltCallbackCh1() or HAL_DACEx_ConvHalfCpltCallbackCh2()
+       (+) Stop the DAC peripheral using HAL_DAC_Stop()
-           function is executed and user can add his own code by customization of function pointer
-           HAL_DAC_ConvCpltCallbackCh1() or HAL_DACEx_ConvHalfCpltCallbackCh2()
+     *** DMA mode IO operation ***
-       (+) In case of transfer Error, HAL_DAC_ErrorCallbackCh1() function is executed and user can
+     ==============================
-            add his own code by customization of function pointer HAL_DAC_ErrorCallbackCh1
+     [..]
-       (+) For STM32F100x devices with specific feature: DMA underrun.
+       (+) Start the DAC peripheral using HAL_DAC_Start_DMA(), at this stage the user specify the length
-           In case of DMA underrun, DAC interruption triggers and execute internal function HAL_DAC_IRQHandler.
+           of data to be transferred at each end of conversion
-           HAL_DAC_DMAUnderrunCallbackCh1() or HAL_DACEx_DMAUnderrunCallbackCh2()
+           First issued trigger will start the conversion of the value previously set by HAL_DAC_SetValue().
-           function is executed and user can add his own code by customization of function pointer
+       (+) At the middle of data transfer HAL_DAC_ConvHalfCpltCallbackCh1() or HAL_DACEx_ConvHalfCpltCallbackCh2()
-           HAL_DAC_DMAUnderrunCallbackCh1() or HAL_DACEx_DMAUnderrunCallbackCh2() and
+           function is executed and user can add his own code by customization of function pointer
-           add his own code by customization of function pointer HAL_DAC_ErrorCallbackCh1()
+           HAL_DAC_ConvHalfCpltCallbackCh1() or HAL_DACEx_ConvHalfCpltCallbackCh2()
-       (+) Stop the DAC peripheral using HAL_DAC_Stop_DMA()
+       (+) At The end of data transfer HAL_DAC_ConvCpltCallbackCh1() or HAL_DACEx_ConvHalfCpltCallbackCh2()
+           function is executed and user can add his own code by customization of function pointer
-    *** Callback registration ***
+           HAL_DAC_ConvCpltCallbackCh1() or HAL_DACEx_ConvHalfCpltCallbackCh2()
-    =============================================
+       (+) In case of transfer Error, HAL_DAC_ErrorCallbackCh1() function is executed and user can
-    [..]
+            add his own code by customization of function pointer HAL_DAC_ErrorCallbackCh1
-      The compilation define  USE_HAL_DAC_REGISTER_CALLBACKS when set to 1
+       (+) For STM32F100x devices with specific feature: DMA underrun.
-      allows the user to configure dynamically the driver callbacks.
+           In case of DMA underrun, DAC interruption triggers and execute internal function HAL_DAC_IRQHandler.
+           HAL_DAC_DMAUnderrunCallbackCh1() or HAL_DACEx_DMAUnderrunCallbackCh2()
-    Use Functions @ref HAL_DAC_RegisterCallback() to register a user callback,
+           function is executed and user can add his own code by customization of function pointer
-      it allows to register following callbacks:
+           HAL_DAC_DMAUnderrunCallbackCh1() or HAL_DACEx_DMAUnderrunCallbackCh2() and
-      (+) ConvCpltCallbackCh1     : callback when a half transfer is completed on Ch1.
+           add his own code by customization of function pointer HAL_DAC_ErrorCallbackCh1()
-      (+) ConvHalfCpltCallbackCh1 : callback when a transfer is completed on Ch1.
+       (+) Stop the DAC peripheral using HAL_DAC_Stop_DMA()
-      (+) ErrorCallbackCh1        : callback when an error occurs on Ch1.
-      (+) DMAUnderrunCallbackCh1  : callback when an underrun error occurs on Ch1.
+    *** Callback registration ***
-      (+) ConvCpltCallbackCh2     : callback when a half transfer is completed on Ch2.
+    =============================================
-      (+) ConvHalfCpltCallbackCh2 : callback when a transfer is completed on Ch2.
+    [..]
-      (+) ErrorCallbackCh2        : callback when an error occurs on Ch2.
+      The compilation define  USE_HAL_DAC_REGISTER_CALLBACKS when set to 1
-      (+) DMAUnderrunCallbackCh2  : callback when an underrun error occurs on Ch2.
+      allows the user to configure dynamically the driver callbacks.
-      (+) MspInitCallback         : DAC MspInit.
-      (+) MspDeInitCallback       : DAC MspdeInit.
+    Use Functions HAL_DAC_RegisterCallback() to register a user callback,
-      This function takes as parameters the HAL peripheral handle, the Callback ID
+      it allows to register following callbacks:
-      and a pointer to the user callback function.
+      (+) ConvCpltCallbackCh1     : callback when a half transfer is completed on Ch1.
+      (+) ConvHalfCpltCallbackCh1 : callback when a transfer is completed on Ch1.
-    Use function @ref HAL_DAC_UnRegisterCallback() to reset a callback to the default
+      (+) ErrorCallbackCh1        : callback when an error occurs on Ch1.
-      weak (surcharged) function. It allows to reset following callbacks:
+      (+) DMAUnderrunCallbackCh1  : callback when an underrun error occurs on Ch1.
-      (+) ConvCpltCallbackCh1     : callback when a half transfer is completed on Ch1.
+      (+) ConvCpltCallbackCh2     : callback when a half transfer is completed on Ch2.
-      (+) ConvHalfCpltCallbackCh1 : callback when a transfer is completed on Ch1.
+      (+) ConvHalfCpltCallbackCh2 : callback when a transfer is completed on Ch2.
-      (+) ErrorCallbackCh1        : callback when an error occurs on Ch1.
+      (+) ErrorCallbackCh2        : callback when an error occurs on Ch2.
-      (+) DMAUnderrunCallbackCh1  : callback when an underrun error occurs on Ch1.
+      (+) DMAUnderrunCallbackCh2  : callback when an underrun error occurs on Ch2.
-      (+) ConvCpltCallbackCh2     : callback when a half transfer is completed on Ch2.
+      (+) MspInitCallback         : DAC MspInit.
-      (+) ConvHalfCpltCallbackCh2 : callback when a transfer is completed on Ch2.
+      (+) MspDeInitCallback       : DAC MspdeInit.
-      (+) ErrorCallbackCh2        : callback when an error occurs on Ch2.
+      This function takes as parameters the HAL peripheral handle, the Callback ID
-      (+) DMAUnderrunCallbackCh2  : callback when an underrun error occurs on Ch2.
+      and a pointer to the user callback function.
-      (+) MspInitCallback         : DAC MspInit.
-      (+) MspDeInitCallback       : DAC MspdeInit.
+    Use function HAL_DAC_UnRegisterCallback() to reset a callback to the default
-      (+) All Callbacks
+      weak (overridden) function. It allows to reset following callbacks:
-      This function) takes as parameters the HAL peripheral handle and the Callback ID.
+      (+) ConvCpltCallbackCh1     : callback when a half transfer is completed on Ch1.
+      (+) ConvHalfCpltCallbackCh1 : callback when a transfer is completed on Ch1.
-      By default, after the @ref HAL_DAC_Init and if the state is HAL_DAC_STATE_RESET
+      (+) ErrorCallbackCh1        : callback when an error occurs on Ch1.
-      all callbacks are reset to the corresponding legacy weak (surcharged) functions.
+      (+) DMAUnderrunCallbackCh1  : callback when an underrun error occurs on Ch1.
-      Exception done for MspInit and MspDeInit callbacks that are respectively
+      (+) ConvCpltCallbackCh2     : callback when a half transfer is completed on Ch2.
-      reset to the legacy weak (surcharged) functions in the @ref HAL_DAC_Init
+      (+) ConvHalfCpltCallbackCh2 : callback when a transfer is completed on Ch2.
-      and @ref  HAL_DAC_DeInit only when these callbacks are null (not registered beforehand).
+      (+) ErrorCallbackCh2        : callback when an error occurs on Ch2.
-      If not, MspInit or MspDeInit are not null, the @ref HAL_DAC_Init and @ref HAL_DAC_DeInit
+      (+) DMAUnderrunCallbackCh2  : callback when an underrun error occurs on Ch2.
-      keep and use the user MspInit/MspDeInit callbacks (registered beforehand)
+      (+) MspInitCallback         : DAC MspInit.
+      (+) MspDeInitCallback       : DAC MspdeInit.
-      Callbacks can be registered/unregistered in READY state only.
+      (+) All Callbacks
-      Exception done for MspInit/MspDeInit callbacks that can be registered/unregistered
+      This function) takes as parameters the HAL peripheral handle and the Callback ID.
-      in READY or RESET state, thus registered (user) MspInit/DeInit callbacks can be used
-      during the Init/DeInit.
+      By default, after the HAL_DAC_Init and if the state is HAL_DAC_STATE_RESET
-      In that case first register the MspInit/MspDeInit user callbacks
+      all callbacks are reset to the corresponding legacy weak (overridden) functions.
-      using @ref HAL_DAC_RegisterCallback before calling @ref HAL_DAC_DeInit
+      Exception done for MspInit and MspDeInit callbacks that are respectively
-      or @ref HAL_DAC_Init function.
+      reset to the legacy weak (overridden) functions in the HAL_DAC_Init
+      and  HAL_DAC_DeInit only when these callbacks are null (not registered beforehand).
-      When The compilation define USE_HAL_DAC_REGISTER_CALLBACKS is set to 0 or
+      If not, MspInit or MspDeInit are not null, the HAL_DAC_Init and HAL_DAC_DeInit
-      not defined, the callback registering feature is not available
+      keep and use the user MspInit/MspDeInit callbacks (registered beforehand)
-      and weak (surcharged) callbacks are used.
+      Callbacks can be registered/unregistered in READY state only.
-     *** DAC HAL driver macros list ***
+      Exception done for MspInit/MspDeInit callbacks that can be registered/unregistered
-     =============================================
+      in READY or RESET state, thus registered (user) MspInit/DeInit callbacks can be used
-     [..]
+      during the Init/DeInit.
-       Below the list of most used macros in DAC HAL driver.
+      In that case first register the MspInit/MspDeInit user callbacks
+      using HAL_DAC_RegisterCallback before calling HAL_DAC_DeInit
-      (+) __HAL_DAC_ENABLE : Enable the DAC peripheral (For STM32F100x devices with specific feature: DMA underrun)
+      or HAL_DAC_Init function.
-      (+) __HAL_DAC_DISABLE : Disable the DAC peripheral (For STM32F100x devices with specific feature: DMA underrun)
-      (+) __HAL_DAC_CLEAR_FLAG: Clear the DAC's pending flags (For STM32F100x devices with specific feature: DMA underrun)
+      When The compilation define USE_HAL_DAC_REGISTER_CALLBACKS is set to 0 or
-      (+) __HAL_DAC_GET_FLAG: Get the selected DAC's flag status (For STM32F100x devices with specific feature: DMA underrun)
+      not defined, the callback registering feature is not available
+      and weak (overridden) callbacks are used.
-     [..]
-      (@) You can refer to the DAC HAL driver header file for more useful macros
+     *** DAC HAL driver macros list ***
+     =============================================
-@endverbatim
+     [..]
-  ******************************************************************************
+       Below the list of most used macros in DAC HAL driver.
-  * @attention
-  *
+      (+) __HAL_DAC_ENABLE : Enable the DAC peripheral (For STM32F100x devices with specific feature: DMA underrun)
-  * <h2><center>&copy; Copyright (c) 2016 STMicroelectronics.
+      (+) __HAL_DAC_DISABLE : Disable the DAC peripheral (For STM32F100x devices with specific feature: DMA underrun)
-  * All rights reserved.</center></h2>
+      (+) __HAL_DAC_CLEAR_FLAG: Clear the DAC's pending flags (For STM32F100x devices with specific feature: DMA underrun)
-  *
+      (+) __HAL_DAC_GET_FLAG: Get the selected DAC's flag status (For STM32F100x devices with specific feature: DMA underrun)
-  * This software component is licensed by ST under BSD 3-Clause license,
-  * the "License"; You may not use this file except in compliance with the
+     [..]
-  * License. You may obtain a copy of the License at:
+      (@) You can refer to the DAC HAL driver header file for more useful macros
-  *                        opensource.org/licenses/BSD-3-Clause
-  *
+@endverbatim
   ******************************************************************************
   */
 /* Includes ------------------------------------------------------------------*/
 #include "stm32f1xx_hal.h"
 /** @addtogroup STM32F1xx_HAL_Driver
   * @{
   */
 #ifdef HAL_DAC_MODULE_ENABLED
 #if defined(DAC)
 /** @defgroup DAC DAC
   * @brief DAC driver modules
   * @{
   */
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 /* Private constants ---------------------------------------------------------*/
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 /* Private function prototypes -----------------------------------------------*/
 /* Exported functions -------------------------------------------------------*/
 /** @defgroup DAC_Exported_Functions DAC Exported Functions
   * @{
   */
 /** @defgroup DAC_Exported_Functions_Group1 Initialization and de-initialization functions
   *  @brief    Initialization and Configuration functions
   *
 @verbatim
   ==============================================================================
               ##### Initialization and de-initialization functions #####
   ==============================================================================
     [..]  This section provides functions allowing to:
       (+) Initialize and configure the DAC.
       (+) De-initialize the DAC.
 @endverbatim
   * @{
   */
 /**
   * @brief  Initialize the DAC peripheral according to the specified parameters
   *         in the DAC_InitStruct and initialize the associated handle.
   * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
   *         the configuration information for the specified DAC.
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_DAC_Init(DAC_HandleTypeDef *hdac)
 {
-  /* Check DAC handle */
+  /* Check the DAC peripheral handle */
   if (hdac == NULL)
   {
     return HAL_ERROR;
   }
   /* Check the parameters */
   assert_param(IS_DAC_ALL_INSTANCE(hdac->Instance));
   if (hdac->State == HAL_DAC_STATE_RESET)
   {
 #if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
     /* Init the DAC Callback settings */
     hdac->ConvCpltCallbackCh1           = HAL_DAC_ConvCpltCallbackCh1;
     hdac->ConvHalfCpltCallbackCh1       = HAL_DAC_ConvHalfCpltCallbackCh1;
     hdac->ErrorCallbackCh1              = HAL_DAC_ErrorCallbackCh1;
     hdac->DMAUnderrunCallbackCh1        = HAL_DAC_DMAUnderrunCallbackCh1;
     hdac->ConvCpltCallbackCh2           = HAL_DACEx_ConvCpltCallbackCh2;
     hdac->ConvHalfCpltCallbackCh2       = HAL_DACEx_ConvHalfCpltCallbackCh2;
     hdac->ErrorCallbackCh2              = HAL_DACEx_ErrorCallbackCh2;
     hdac->DMAUnderrunCallbackCh2        = HAL_DACEx_DMAUnderrunCallbackCh2;
     if (hdac->MspInitCallback == NULL)
     {
       hdac->MspInitCallback             = HAL_DAC_MspInit;
     }
 #endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
     /* Allocate lock resource and initialize it */
     hdac->Lock = HAL_UNLOCKED;
 #if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
     /* Init the low level hardware */
     hdac->MspInitCallback(hdac);
 #else
     /* Init the low level hardware */
     HAL_DAC_MspInit(hdac);
 #endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
   }
   /* Initialize the DAC state*/
   hdac->State = HAL_DAC_STATE_BUSY;
   /* Set DAC error code to none */
   hdac->ErrorCode = HAL_DAC_ERROR_NONE;
   /* Initialize the DAC state*/
   hdac->State = HAL_DAC_STATE_READY;
   /* Return function status */
   return HAL_OK;
 }
 /**
   * @brief  Deinitialize the DAC peripheral registers to their default reset values.
   * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
   *         the configuration information for the specified DAC.
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_DAC_DeInit(DAC_HandleTypeDef *hdac)
 {
-  /* Check DAC handle */
+  /* Check the DAC peripheral handle */
   if (hdac == NULL)
   {
     return HAL_ERROR;
   }
   /* Check the parameters */
   assert_param(IS_DAC_ALL_INSTANCE(hdac->Instance));
   /* Change DAC state */
   hdac->State = HAL_DAC_STATE_BUSY;
 #if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
   if (hdac->MspDeInitCallback == NULL)
   {
     hdac->MspDeInitCallback = HAL_DAC_MspDeInit;
   }
   /* DeInit the low level hardware */
   hdac->MspDeInitCallback(hdac);
 #else
   /* DeInit the low level hardware */
   HAL_DAC_MspDeInit(hdac);
 #endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
   /* Set DAC error code to none */
   hdac->ErrorCode = HAL_DAC_ERROR_NONE;
   /* Change DAC state */
   hdac->State = HAL_DAC_STATE_RESET;
   /* Release Lock */
   __HAL_UNLOCK(hdac);
   /* Return function status */
   return HAL_OK;
 }
 /**
   * @brief  Initialize the DAC MSP.
   * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
   *         the configuration information for the specified DAC.
   * @retval None
   */
 __weak void HAL_DAC_MspInit(DAC_HandleTypeDef *hdac)
 {
   /* Prevent unused argument(s) compilation warning */
   UNUSED(hdac);
   /* NOTE : This function should not be modified, when the callback is needed,
             the HAL_DAC_MspInit could be implemented in the user file
    */
 }
 /**
   * @brief  DeInitialize the DAC MSP.
   * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
   *         the configuration information for the specified DAC.
   * @retval None
   */
 __weak void HAL_DAC_MspDeInit(DAC_HandleTypeDef *hdac)
 {
   /* Prevent unused argument(s) compilation warning */
   UNUSED(hdac);
   /* NOTE : This function should not be modified, when the callback is needed,
             the HAL_DAC_MspDeInit could be implemented in the user file
    */
 }
 /**
   * @}
   */
 /** @defgroup DAC_Exported_Functions_Group2 IO operation functions
   *  @brief    IO operation functions
   *
 @verbatim
   ==============================================================================
              ##### IO operation functions #####
   ==============================================================================
     [..]  This section provides functions allowing to:
       (+) Start conversion.
       (+) Stop conversion.
       (+) Start conversion and enable DMA transfer.
       (+) Stop conversion and disable DMA transfer.
       (+) Get result of conversion.
 @endverbatim
   * @{
   */
 /**
   * @brief  Enables DAC and starts conversion of channel.
   * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
   *         the configuration information for the specified DAC.
   * @param  Channel The selected DAC channel.
   *          This parameter can be one of the following values:
   *            @arg DAC_CHANNEL_1: DAC Channel1 selected
   *            @arg DAC_CHANNEL_2: DAC Channel2 selected
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_DAC_Start(DAC_HandleTypeDef *hdac, uint32_t Channel)
 {
-  /* Check the parameters */
+  /* Check the DAC peripheral handle */
-  assert_param(IS_DAC_CHANNEL(Channel));
+  if (hdac == NULL)
+  {
-  /* Process locked */
+    return HAL_ERROR;
-  __HAL_LOCK(hdac);
+  }
-  /* Change DAC state */
+  /* Check the parameters */
-  hdac->State = HAL_DAC_STATE_BUSY;
+  assert_param(IS_DAC_CHANNEL(Channel));
-  /* Enable the Peripheral */
+  /* Process locked */
-  __HAL_DAC_ENABLE(hdac, Channel);
+  __HAL_LOCK(hdac);
-  if (Channel == DAC_CHANNEL_1)
+  /* Change DAC state */
-  {
+  hdac->State = HAL_DAC_STATE_BUSY;
-    /* Check if software trigger enabled */
-    if ((hdac->Instance->CR & (DAC_CR_TEN1 | DAC_CR_TSEL1)) == DAC_TRIGGER_SOFTWARE)
+  /* Enable the Peripheral */
-    {
+  __HAL_DAC_ENABLE(hdac, Channel);
-      /* Enable the selected DAC software conversion */
-      SET_BIT(hdac->Instance->SWTRIGR, DAC_SWTRIGR_SWTRIG1);
+  if (Channel == DAC_CHANNEL_1)
-    }
+  {
-  }
+    /* Check if software trigger enabled */
+    if ((hdac->Instance->CR & (DAC_CR_TEN1 | DAC_CR_TSEL1)) == DAC_TRIGGER_SOFTWARE)
-  else
+    {
-  {
+      /* Enable the selected DAC software conversion */
-    /* Check if software trigger enabled */
+      SET_BIT(hdac->Instance->SWTRIGR, DAC_SWTRIGR_SWTRIG1);
-    if ((hdac->Instance->CR & (DAC_CR_TEN2 | DAC_CR_TSEL2)) == (DAC_TRIGGER_SOFTWARE << (Channel & 0x10UL)))
+    }
-    {
+  }
-      /* Enable the selected DAC software conversion*/
-      SET_BIT(hdac->Instance->SWTRIGR, DAC_SWTRIGR_SWTRIG2);
+  else
-    }
+  {
-  }
+    /* Check if software trigger enabled */
+    if ((hdac->Instance->CR & (DAC_CR_TEN2 | DAC_CR_TSEL2)) == (DAC_TRIGGER_SOFTWARE << (Channel & 0x10UL)))
+    {
-  /* Change DAC state */
+      /* Enable the selected DAC software conversion*/
-  hdac->State = HAL_DAC_STATE_READY;
+      SET_BIT(hdac->Instance->SWTRIGR, DAC_SWTRIGR_SWTRIG2);
+    }
-  /* Process unlocked */
+  }
-  __HAL_UNLOCK(hdac);
-  /* Return function status */
+  /* Change DAC state */
-  return HAL_OK;
+  hdac->State = HAL_DAC_STATE_READY;
-}
+  /* Process unlocked */
-/**
+  __HAL_UNLOCK(hdac);
-  * @brief  Disables DAC and stop conversion of channel.
-  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
+  /* Return function status */
-  *         the configuration information for the specified DAC.
+  return HAL_OK;
-  * @param  Channel The selected DAC channel.
+}
-  *          This parameter can be one of the following values:
-  *            @arg DAC_CHANNEL_1: DAC Channel1 selected
+/**
-  *            @arg DAC_CHANNEL_2: DAC Channel2 selected
+  * @brief  Disables DAC and stop conversion of channel.
-  * @retval HAL status
+  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
-  */
+  *         the configuration information for the specified DAC.
-HAL_StatusTypeDef HAL_DAC_Stop(DAC_HandleTypeDef *hdac, uint32_t Channel)
+  * @param  Channel The selected DAC channel.
-{
+  *          This parameter can be one of the following values:
-  /* Check the parameters */
+  *            @arg DAC_CHANNEL_1: DAC Channel1 selected
-  assert_param(IS_DAC_CHANNEL(Channel));
+  *            @arg DAC_CHANNEL_2: DAC Channel2 selected
+  * @retval HAL status
-  /* Disable the Peripheral */
+  */
-  __HAL_DAC_DISABLE(hdac, Channel);
+HAL_StatusTypeDef HAL_DAC_Stop(DAC_HandleTypeDef *hdac, uint32_t Channel)
+{
-  /* Change DAC state */
+  /* Check the DAC peripheral handle */
-  hdac->State = HAL_DAC_STATE_READY;
+  if (hdac == NULL)
+  {
-  /* Return function status */
+    return HAL_ERROR;
-  return HAL_OK;
+  }
-}
+  /* Check the parameters */
-/**
+  assert_param(IS_DAC_CHANNEL(Channel));
-  * @brief  Enables DAC and starts conversion of channel.
-  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
+  /* Disable the Peripheral */
-  *         the configuration information for the specified DAC.
+  __HAL_DAC_DISABLE(hdac, Channel);
-  * @param  Channel The selected DAC channel.
-  *          This parameter can be one of the following values:
+  /* Change DAC state */
-  *            @arg DAC_CHANNEL_1: DAC Channel1 selected
+  hdac->State = HAL_DAC_STATE_READY;
-  *            @arg DAC_CHANNEL_2: DAC Channel2 selected
-  * @param  pData The source Buffer address.
+  /* Return function status */
-  * @param  Length The length of data to be transferred from memory to DAC peripheral
+  return HAL_OK;
-  * @param  Alignment Specifies the data alignment for DAC channel.
+}
-  *          This parameter can be one of the following values:
-  *            @arg DAC_ALIGN_8B_R: 8bit right data alignment selected
+/**
-  *            @arg DAC_ALIGN_12B_L: 12bit left data alignment selected
+  * @brief  Enables DAC and starts conversion of channel.
-  *            @arg DAC_ALIGN_12B_R: 12bit right data alignment selected
+  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
-  * @retval HAL status
+  *         the configuration information for the specified DAC.
-  */
+  * @param  Channel The selected DAC channel.
-HAL_StatusTypeDef HAL_DAC_Start_DMA(DAC_HandleTypeDef *hdac, uint32_t Channel, uint32_t *pData, uint32_t Length,
+  *          This parameter can be one of the following values:
-                                    uint32_t Alignment)
+  *            @arg DAC_CHANNEL_1: DAC Channel1 selected
-{
+  *            @arg DAC_CHANNEL_2: DAC Channel2 selected
-  HAL_StatusTypeDef status;
+  * @param  pData The source Buffer address.
-  uint32_t tmpreg = 0U;
+  * @param  Length The length of data to be transferred from memory to DAC peripheral
+  * @param  Alignment Specifies the data alignment for DAC channel.
-  /* Check the parameters */
+  *          This parameter can be one of the following values:
-  assert_param(IS_DAC_CHANNEL(Channel));
+  *            @arg DAC_ALIGN_8B_R: 8bit right data alignment selected
-  assert_param(IS_DAC_ALIGN(Alignment));
+  *            @arg DAC_ALIGN_12B_L: 12bit left data alignment selected
+  *            @arg DAC_ALIGN_12B_R: 12bit right data alignment selected
-  /* Process locked */
+  * @retval HAL status
-  __HAL_LOCK(hdac);
+  */
+HAL_StatusTypeDef HAL_DAC_Start_DMA(DAC_HandleTypeDef *hdac, uint32_t Channel, const uint32_t *pData, uint32_t Length,
-  /* Change DAC state */
+                                    uint32_t Alignment)
-  hdac->State = HAL_DAC_STATE_BUSY;
+{
+  HAL_StatusTypeDef status;
-  if (Channel == DAC_CHANNEL_1)
+  uint32_t tmpreg;
-  {
-    /* Set the DMA transfer complete callback for channel1 */
+  /* Check the DAC peripheral handle */
-    hdac->DMA_Handle1->XferCpltCallback = DAC_DMAConvCpltCh1;
+  if (hdac == NULL)
+  {
-    /* Set the DMA half transfer complete callback for channel1 */
+    return HAL_ERROR;
-    hdac->DMA_Handle1->XferHalfCpltCallback = DAC_DMAHalfConvCpltCh1;
+  }
-    /* Set the DMA error callback for channel1 */
+  /* Check the parameters */
-    hdac->DMA_Handle1->XferErrorCallback = DAC_DMAErrorCh1;
+  assert_param(IS_DAC_CHANNEL(Channel));
+  assert_param(IS_DAC_ALIGN(Alignment));
-    /* Enable the selected DAC channel1 DMA request */
-    SET_BIT(hdac->Instance->CR, DAC_CR_DMAEN1);
+  /* Process locked */
+  __HAL_LOCK(hdac);
-    /* Case of use of channel 1 */
-    switch (Alignment)
+  /* Change DAC state */
-    {
+  hdac->State = HAL_DAC_STATE_BUSY;
-      case DAC_ALIGN_12B_R:
-        /* Get DHR12R1 address */
+  if (Channel == DAC_CHANNEL_1)
-        tmpreg = (uint32_t)&hdac->Instance->DHR12R1;
+  {
-        break;
+    /* Set the DMA transfer complete callback for channel1 */
-      case DAC_ALIGN_12B_L:
+    hdac->DMA_Handle1->XferCpltCallback = DAC_DMAConvCpltCh1;
-        /* Get DHR12L1 address */
-        tmpreg = (uint32_t)&hdac->Instance->DHR12L1;
+    /* Set the DMA half transfer complete callback for channel1 */
-        break;
+    hdac->DMA_Handle1->XferHalfCpltCallback = DAC_DMAHalfConvCpltCh1;
-      case DAC_ALIGN_8B_R:
-        /* Get DHR8R1 address */
+    /* Set the DMA error callback for channel1 */
-        tmpreg = (uint32_t)&hdac->Instance->DHR8R1;
+    hdac->DMA_Handle1->XferErrorCallback = DAC_DMAErrorCh1;
-        break;
-      default:
+    /* Enable the selected DAC channel1 DMA request */
-        break;
+    SET_BIT(hdac->Instance->CR, DAC_CR_DMAEN1);
-    }
-  }
+    /* Case of use of channel 1 */
+    switch (Alignment)
-  else
+    {
-  {
+      case DAC_ALIGN_12B_R:
-    /* Set the DMA transfer complete callback for channel2 */
+        /* Get DHR12R1 address */
-    hdac->DMA_Handle2->XferCpltCallback = DAC_DMAConvCpltCh2;
+        tmpreg = (uint32_t)&hdac->Instance->DHR12R1;
+        break;
-    /* Set the DMA half transfer complete callback for channel2 */
+      case DAC_ALIGN_12B_L:
-    hdac->DMA_Handle2->XferHalfCpltCallback = DAC_DMAHalfConvCpltCh2;
+        /* Get DHR12L1 address */
+        tmpreg = (uint32_t)&hdac->Instance->DHR12L1;
-    /* Set the DMA error callback for channel2 */
+        break;
-    hdac->DMA_Handle2->XferErrorCallback = DAC_DMAErrorCh2;
+      default: /* case DAC_ALIGN_8B_R */
+        /* Get DHR8R1 address */
-    /* Enable the selected DAC channel2 DMA request */
+        tmpreg = (uint32_t)&hdac->Instance->DHR8R1;
-    SET_BIT(hdac->Instance->CR, DAC_CR_DMAEN2);
+        break;
+    }
-    /* Case of use of channel 2 */
+  }
-    switch (Alignment)
-    {
+  else
-      case DAC_ALIGN_12B_R:
+  {
-        /* Get DHR12R2 address */
+    /* Set the DMA transfer complete callback for channel2 */
-        tmpreg = (uint32_t)&hdac->Instance->DHR12R2;
+    hdac->DMA_Handle2->XferCpltCallback = DAC_DMAConvCpltCh2;
-        break;
-      case DAC_ALIGN_12B_L:
+    /* Set the DMA half transfer complete callback for channel2 */
-        /* Get DHR12L2 address */
+    hdac->DMA_Handle2->XferHalfCpltCallback = DAC_DMAHalfConvCpltCh2;
-        tmpreg = (uint32_t)&hdac->Instance->DHR12L2;
-        break;
+    /* Set the DMA error callback for channel2 */
-      case DAC_ALIGN_8B_R:
+    hdac->DMA_Handle2->XferErrorCallback = DAC_DMAErrorCh2;
-        /* Get DHR8R2 address */
-        tmpreg = (uint32_t)&hdac->Instance->DHR8R2;
+    /* Enable the selected DAC channel2 DMA request */
-        break;
+    SET_BIT(hdac->Instance->CR, DAC_CR_DMAEN2);
-      default:
-        break;
+    /* Case of use of channel 2 */
-    }
+    switch (Alignment)
-  }
+    {
+      case DAC_ALIGN_12B_R:
+        /* Get DHR12R2 address */
-  /* Enable the DMA Stream */
+        tmpreg = (uint32_t)&hdac->Instance->DHR12R2;
-  if (Channel == DAC_CHANNEL_1)
+        break;
-  {
+      case DAC_ALIGN_12B_L:
-#if defined(DAC_CR_DMAUDRIE1)
+        /* Get DHR12L2 address */
-    /* Enable the DAC DMA underrun interrupt */
+        tmpreg = (uint32_t)&hdac->Instance->DHR12L2;
-    __HAL_DAC_ENABLE_IT(hdac, DAC_IT_DMAUDR1);
+        break;
-#endif /* DAC_CR_DMAUDRIE1 */
+      default: /* case DAC_ALIGN_8B_R */
+        /* Get DHR8R2 address */
-    /* Enable the DMA Stream */
+        tmpreg = (uint32_t)&hdac->Instance->DHR8R2;
-    status = HAL_DMA_Start_IT(hdac->DMA_Handle1, (uint32_t)pData, tmpreg, Length);
+        break;
-  }
+    }
+  }
-  else
-  {
+  if (Channel == DAC_CHANNEL_1)
-#if defined(DAC_CR_DMAUDRIE2)
+  {
-    /* Enable the DAC DMA underrun interrupt */
+#if defined(DAC_CR_DMAUDRIE1)
-    __HAL_DAC_ENABLE_IT(hdac, DAC_IT_DMAUDR2);
+    /* Enable the DAC DMA underrun interrupt */
-#endif /* DAC_CR_DMAUDRIE2 */
+    __HAL_DAC_ENABLE_IT(hdac, DAC_IT_DMAUDR1);
+#endif /* DAC_CR_DMAUDRIE1 */
-    /* Enable the DMA Stream */
-    status = HAL_DMA_Start_IT(hdac->DMA_Handle2, (uint32_t)pData, tmpreg, Length);
+    /* Enable the DMA Stream */
-  }
+    status = HAL_DMA_Start_IT(hdac->DMA_Handle1, (uint32_t)pData, tmpreg, Length);
+  }
-  /* Process Unlocked */
+  else
-  __HAL_UNLOCK(hdac);
+  {
+#if defined(DAC_CR_DMAUDRIE2)
-  if (status == HAL_OK)
+    /* Enable the DAC DMA underrun interrupt */
-  {
+    __HAL_DAC_ENABLE_IT(hdac, DAC_IT_DMAUDR2);
-    /* Enable the Peripheral */
+#endif /* DAC_CR_DMAUDRIE2 */
-    __HAL_DAC_ENABLE(hdac, Channel);
-  }
+    /* Enable the DMA Stream */
-  else
+    status = HAL_DMA_Start_IT(hdac->DMA_Handle2, (uint32_t)pData, tmpreg, Length);
-  {
+  }
-    hdac->ErrorCode |= HAL_DAC_ERROR_DMA;
-  }
+  /* Process Unlocked */
-  /* Return function status */
+  __HAL_UNLOCK(hdac);
-  return status;
-}
+  if (status == HAL_OK)
+  {
-/**
+    /* Enable the Peripheral */
-  * @brief  Disables DAC and stop conversion of channel.
+    __HAL_DAC_ENABLE(hdac, Channel);
-  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
+  }
-  *         the configuration information for the specified DAC.
+  else
-  * @param  Channel The selected DAC channel.
+  {
-  *          This parameter can be one of the following values:
+    hdac->ErrorCode |= HAL_DAC_ERROR_DMA;
-  *            @arg DAC_CHANNEL_1: DAC Channel1 selected
+  }
-  *            @arg DAC_CHANNEL_2: DAC Channel2 selected
-  * @retval HAL status
+  /* Return function status */
-  */
+  return status;
-HAL_StatusTypeDef HAL_DAC_Stop_DMA(DAC_HandleTypeDef *hdac, uint32_t Channel)
+}
-{
-  /* Check the parameters */
+/**
-  assert_param(IS_DAC_CHANNEL(Channel));
+  * @brief  Disables DAC and stop conversion of channel.
+  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
-  /* Disable the selected DAC channel DMA request */
+  *         the configuration information for the specified DAC.
-  hdac->Instance->CR &= ~(DAC_CR_DMAEN1 << (Channel & 0x10UL));
+  * @param  Channel The selected DAC channel.
+  *          This parameter can be one of the following values:
-  /* Disable the Peripheral */
+  *            @arg DAC_CHANNEL_1: DAC Channel1 selected
-  __HAL_DAC_DISABLE(hdac, Channel);
+  *            @arg DAC_CHANNEL_2: DAC Channel2 selected
+  * @retval HAL status
-  /* Disable the DMA Stream */
+  */
+HAL_StatusTypeDef HAL_DAC_Stop_DMA(DAC_HandleTypeDef *hdac, uint32_t Channel)
-  /* Channel1 is used */
+{
-  if (Channel == DAC_CHANNEL_1)
+  /* Check the DAC peripheral handle */
-  {
+  if (hdac == NULL)
-    /* Disable the DMA Stream */
+  {
-    (void)HAL_DMA_Abort(hdac->DMA_Handle1);
+    return HAL_ERROR;
-#if defined(DAC_CR_DMAUDRIE1)
+  }
-    /* Disable the DAC DMA underrun interrupt */
-    __HAL_DAC_DISABLE_IT(hdac, DAC_IT_DMAUDR1);
+  /* Check the parameters */
-#endif /* DAC_CR_DMAUDRIE1 */
+  assert_param(IS_DAC_CHANNEL(Channel));
-  }
+  /* Disable the selected DAC channel DMA request */
-  else /* Channel2 is used for */
+  hdac->Instance->CR &= ~(DAC_CR_DMAEN1 << (Channel & 0x10UL));
-  {
-    /* Disable the DMA Stream */
+  /* Disable the Peripheral */
-    (void)HAL_DMA_Abort(hdac->DMA_Handle2);
+  __HAL_DAC_DISABLE(hdac, Channel);
-#if defined(DAC_CR_DMAUDRIE2)
-    /* Disable the DAC DMA underrun interrupt */
+  /* Disable the DMA Stream */
-    __HAL_DAC_DISABLE_IT(hdac, DAC_IT_DMAUDR2);
-#endif /* DAC_CR_DMAUDRIE2 */
+  /* Channel1 is used */
-  }
+  if (Channel == DAC_CHANNEL_1)
+  {
+    /* Disable the DMA Stream */
-  /* Change DAC state */
+    (void)HAL_DMA_Abort(hdac->DMA_Handle1);
-  hdac->State = HAL_DAC_STATE_READY;
+#if defined(DAC_CR_DMAUDRIE1)
-  /* Return function status */
+    /* Disable the DAC DMA underrun interrupt */
-  return HAL_OK;
+    __HAL_DAC_DISABLE_IT(hdac, DAC_IT_DMAUDR1);
-}
+#endif /* DAC_CR_DMAUDRIE1 */
+  }
-/**
-  * @brief  Handles DAC interrupt request
+  else /* Channel2 is used for */
-  *         This function uses the interruption of DMA
+  {
-  *         underrun.
+    /* Disable the DMA Stream */
-  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
+    (void)HAL_DMA_Abort(hdac->DMA_Handle2);
-  *         the configuration information for the specified DAC.
-  * @retval None
+#if defined(DAC_CR_DMAUDRIE2)
-  */
+    /* Disable the DAC DMA underrun interrupt */
-void HAL_DAC_IRQHandler(DAC_HandleTypeDef *hdac)
+    __HAL_DAC_DISABLE_IT(hdac, DAC_IT_DMAUDR2);
-{
+#endif /* DAC_CR_DMAUDRIE2 */
-#if !defined(DAC_SR_DMAUDR1) && !defined(DAC_SR_DMAUDR2)
+  }
-  UNUSED(hdac);
-#endif
+  /* Change DAC state */
-#if defined(DAC_SR_DMAUDR1)
+  hdac->State = HAL_DAC_STATE_READY;
-  if (__HAL_DAC_GET_IT_SOURCE(hdac, DAC_IT_DMAUDR1))
-  {
+  /* Return function status */
-    /* Check underrun flag of DAC channel 1 */
+  return HAL_OK;
-    if (__HAL_DAC_GET_FLAG(hdac, DAC_FLAG_DMAUDR1))
+}
-    {
-      /* Change DAC state to error state */
+/**
-      hdac->State = HAL_DAC_STATE_ERROR;
+  * @brief  Handles DAC interrupt request
+  *         This function uses the interruption of DMA
-      /* Set DAC error code to channel1 DMA underrun error */
+  *         underrun.
-      SET_BIT(hdac->ErrorCode, HAL_DAC_ERROR_DMAUNDERRUNCH1);
+  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
+  *         the configuration information for the specified DAC.
-      /* Clear the underrun flag */
+  * @retval None
-      __HAL_DAC_CLEAR_FLAG(hdac, DAC_FLAG_DMAUDR1);
+  */
+void HAL_DAC_IRQHandler(DAC_HandleTypeDef *hdac)
-      /* Disable the selected DAC channel1 DMA request */
+{
-      CLEAR_BIT(hdac->Instance->CR, DAC_CR_DMAEN1);
+#if !defined(DAC_SR_DMAUDR1) && !defined(DAC_SR_DMAUDR2)
+  UNUSED(hdac);
-      /* Error callback */
+#else
-#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
+  uint32_t itsource = hdac->Instance->CR;
-      hdac->DMAUnderrunCallbackCh1(hdac);
+  uint32_t itflag   = hdac->Instance->SR;
-#else
+#endif /* !DAC_SR_DMAUDR1 && !DAC_SR_DMAUDR2 */
-      HAL_DAC_DMAUnderrunCallbackCh1(hdac);
-#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
+#if defined(DAC_SR_DMAUDR1)
-    }
+  if ((itsource & DAC_IT_DMAUDR1) == DAC_IT_DMAUDR1)
-  }
+  {
-#endif /* DAC_SR_DMAUDR1 */
+    /* Check underrun flag of DAC channel 1 */
+    if ((itflag & DAC_FLAG_DMAUDR1) == DAC_FLAG_DMAUDR1)
-#if defined(DAC_SR_DMAUDR2)
+    {
-  if (__HAL_DAC_GET_IT_SOURCE(hdac, DAC_IT_DMAUDR2))
+      /* Change DAC state to error state */
-  {
+      hdac->State = HAL_DAC_STATE_ERROR;
-    /* Check underrun flag of DAC channel 2 */
-    if (__HAL_DAC_GET_FLAG(hdac, DAC_FLAG_DMAUDR2))
+      /* Set DAC error code to channel1 DMA underrun error */
-    {
+      SET_BIT(hdac->ErrorCode, HAL_DAC_ERROR_DMAUNDERRUNCH1);
-      /* Change DAC state to error state */
-      hdac->State = HAL_DAC_STATE_ERROR;
+      /* Clear the underrun flag */
+      __HAL_DAC_CLEAR_FLAG(hdac, DAC_FLAG_DMAUDR1);
-      /* Set DAC error code to channel2 DMA underrun error */
-      SET_BIT(hdac->ErrorCode, HAL_DAC_ERROR_DMAUNDERRUNCH2);
+      /* Disable the selected DAC channel1 DMA request */
+      __HAL_DAC_DISABLE_IT(hdac, DAC_CR_DMAEN1);
-      /* Clear the underrun flag */
-      __HAL_DAC_CLEAR_FLAG(hdac, DAC_FLAG_DMAUDR2);
+      /* Error callback */
+#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
-      /* Disable the selected DAC channel2 DMA request */
+      hdac->DMAUnderrunCallbackCh1(hdac);
-      CLEAR_BIT(hdac->Instance->CR, DAC_CR_DMAEN2);
+#else
+      HAL_DAC_DMAUnderrunCallbackCh1(hdac);
-      /* Error callback */
+#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
-#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
+    }
-      hdac->DMAUnderrunCallbackCh2(hdac);
+  }
-#else
+#endif /* DAC_SR_DMAUDR1 */
-      HAL_DACEx_DMAUnderrunCallbackCh2(hdac);
-#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
+#if defined(DAC_SR_DMAUDR2)
-    }
+  if ((itsource & DAC_IT_DMAUDR2) == DAC_IT_DMAUDR2)
-  }
+  {
-#endif /* DAC_SR_DMAUDR2 */
+    /* Check underrun flag of DAC channel 2 */
-}
+    if ((itflag & DAC_FLAG_DMAUDR2) == DAC_FLAG_DMAUDR2)
+    {
-/**
+      /* Change DAC state to error state */
-  * @brief  Set the specified data holding register value for DAC channel.
+      hdac->State = HAL_DAC_STATE_ERROR;
-  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
-  *         the configuration information for the specified DAC.
+      /* Set DAC error code to channel2 DMA underrun error */
-  * @param  Channel The selected DAC channel.
+      SET_BIT(hdac->ErrorCode, HAL_DAC_ERROR_DMAUNDERRUNCH2);
-  *          This parameter can be one of the following values:
-  *            @arg DAC_CHANNEL_1: DAC Channel1 selected
+      /* Clear the underrun flag */
-  *            @arg DAC_CHANNEL_2: DAC Channel2 selected
+      __HAL_DAC_CLEAR_FLAG(hdac, DAC_FLAG_DMAUDR2);
-  * @param  Alignment Specifies the data alignment.
-  *          This parameter can be one of the following values:
+      /* Disable the selected DAC channel2 DMA request */
-  *            @arg DAC_ALIGN_8B_R: 8bit right data alignment selected
+      __HAL_DAC_DISABLE_IT(hdac,  DAC_CR_DMAEN2);
-  *            @arg DAC_ALIGN_12B_L: 12bit left data alignment selected
-  *            @arg DAC_ALIGN_12B_R: 12bit right data alignment selected
+      /* Error callback */
-  * @param  Data Data to be loaded in the selected data holding register.
+#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
-  * @retval HAL status
+      hdac->DMAUnderrunCallbackCh2(hdac);
-  */
+#else
-HAL_StatusTypeDef HAL_DAC_SetValue(DAC_HandleTypeDef *hdac, uint32_t Channel, uint32_t Alignment, uint32_t Data)
+      HAL_DACEx_DMAUnderrunCallbackCh2(hdac);
-{
+#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
-  __IO uint32_t tmp = 0UL;
+    }
+  }
-  /* Check the parameters */
+#endif /* DAC_SR_DMAUDR2 */
-  assert_param(IS_DAC_CHANNEL(Channel));
+}
-  assert_param(IS_DAC_ALIGN(Alignment));
-  assert_param(IS_DAC_DATA(Data));
+/**
+  * @brief  Set the specified data holding register value for DAC channel.
-  tmp = (uint32_t)hdac->Instance;
+  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
-  if (Channel == DAC_CHANNEL_1)
+  *         the configuration information for the specified DAC.
-  {
+  * @param  Channel The selected DAC channel.
-    tmp += DAC_DHR12R1_ALIGNMENT(Alignment);
+  *          This parameter can be one of the following values:
-  }
+  *            @arg DAC_CHANNEL_1: DAC Channel1 selected
+  *            @arg DAC_CHANNEL_2: DAC Channel2 selected
-  else
+  * @param  Alignment Specifies the data alignment.
-  {
+  *          This parameter can be one of the following values:
-    tmp += DAC_DHR12R2_ALIGNMENT(Alignment);
+  *            @arg DAC_ALIGN_8B_R: 8bit right data alignment selected
-  }
+  *            @arg DAC_ALIGN_12B_L: 12bit left data alignment selected
+  *            @arg DAC_ALIGN_12B_R: 12bit right data alignment selected
+  * @param  Data Data to be loaded in the selected data holding register.
-  /* Set the DAC channel selected data holding register */
+  * @retval HAL status
-  *(__IO uint32_t *) tmp = Data;
+  */
+HAL_StatusTypeDef HAL_DAC_SetValue(DAC_HandleTypeDef *hdac, uint32_t Channel, uint32_t Alignment, uint32_t Data)
-  /* Return function status */
+{
-  return HAL_OK;
+  __IO uint32_t tmp = 0UL;
-}
+  /* Check the DAC peripheral handle */
-/**
+  if (hdac == NULL)
-  * @brief  Conversion complete callback in non-blocking mode for Channel1
+  {
-  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
+    return HAL_ERROR;
-  *         the configuration information for the specified DAC.
+  }
-  * @retval None
-  */
+  /* Check the parameters */
-__weak void HAL_DAC_ConvCpltCallbackCh1(DAC_HandleTypeDef *hdac)
+  assert_param(IS_DAC_CHANNEL(Channel));
-{
+  assert_param(IS_DAC_ALIGN(Alignment));
-  /* Prevent unused argument(s) compilation warning */
+  assert_param(IS_DAC_DATA(Data));
-  UNUSED(hdac);
+  tmp = (uint32_t)hdac->Instance;
-  /* NOTE : This function should not be modified, when the callback is needed,
+  if (Channel == DAC_CHANNEL_1)
-            the HAL_DAC_ConvCpltCallbackCh1 could be implemented in the user file
+  {
-   */
+    tmp += DAC_DHR12R1_ALIGNMENT(Alignment);
-}
+  }
-/**
+  else
-  * @brief  Conversion half DMA transfer callback in non-blocking mode for Channel1
+  {
-  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
+    tmp += DAC_DHR12R2_ALIGNMENT(Alignment);
-  *         the configuration information for the specified DAC.
+  }
-  * @retval None
-  */
-__weak void HAL_DAC_ConvHalfCpltCallbackCh1(DAC_HandleTypeDef *hdac)
+  /* Set the DAC channel selected data holding register */
-{
+  *(__IO uint32_t *) tmp = Data;
-  /* Prevent unused argument(s) compilation warning */
-  UNUSED(hdac);
+  /* Return function status */
+  return HAL_OK;
-  /* NOTE : This function should not be modified, when the callback is needed,
+}
-            the HAL_DAC_ConvHalfCpltCallbackCh1 could be implemented in the user file
-   */
+/**
-}
+  * @brief  Conversion complete callback in non-blocking mode for Channel1
+  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
-/**
+  *         the configuration information for the specified DAC.
-  * @brief  Error DAC callback for Channel1.
+  * @retval None
-  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
+  */
-  *         the configuration information for the specified DAC.
+__weak void HAL_DAC_ConvCpltCallbackCh1(DAC_HandleTypeDef *hdac)
-  * @retval None
+{
-  */
+  /* Prevent unused argument(s) compilation warning */
-__weak void HAL_DAC_ErrorCallbackCh1(DAC_HandleTypeDef *hdac)
+  UNUSED(hdac);
-{
-  /* Prevent unused argument(s) compilation warning */
+  /* NOTE : This function should not be modified, when the callback is needed,
-  UNUSED(hdac);
+            the HAL_DAC_ConvCpltCallbackCh1 could be implemented in the user file
+   */
-  /* NOTE : This function should not be modified, when the callback is needed,
+}
-            the HAL_DAC_ErrorCallbackCh1 could be implemented in the user file
-   */
+/**
-}
+  * @brief  Conversion half DMA transfer callback in non-blocking mode for Channel1
+  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
-/**
+  *         the configuration information for the specified DAC.
-  * @brief  DMA underrun DAC callback for channel1.
+  * @retval None
-  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
+  */
-  *         the configuration information for the specified DAC.
+__weak void HAL_DAC_ConvHalfCpltCallbackCh1(DAC_HandleTypeDef *hdac)
-  * @retval None
+{
-  */
+  /* Prevent unused argument(s) compilation warning */
-__weak void HAL_DAC_DMAUnderrunCallbackCh1(DAC_HandleTypeDef *hdac)
+  UNUSED(hdac);
-{
-  /* Prevent unused argument(s) compilation warning */
+  /* NOTE : This function should not be modified, when the callback is needed,
-  UNUSED(hdac);
+            the HAL_DAC_ConvHalfCpltCallbackCh1 could be implemented in the user file
+   */
-  /* NOTE : This function should not be modified, when the callback is needed,
+}
-            the HAL_DAC_DMAUnderrunCallbackCh1 could be implemented in the user file
-   */
+/**
-}
+  * @brief  Error DAC callback for Channel1.
+  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
-/**
+  *         the configuration information for the specified DAC.
-  * @}
+  * @retval None
   */
+__weak void HAL_DAC_ErrorCallbackCh1(DAC_HandleTypeDef *hdac)
-/** @defgroup DAC_Exported_Functions_Group3 Peripheral Control functions
+{
-  *  @brief    Peripheral Control functions
+  /* Prevent unused argument(s) compilation warning */
-  *
+  UNUSED(hdac);
-@verbatim
-  ==============================================================================
+  /* NOTE : This function should not be modified, when the callback is needed,
-             ##### Peripheral Control functions #####
+            the HAL_DAC_ErrorCallbackCh1 could be implemented in the user file
-  ==============================================================================
+   */
-    [..]  This section provides functions allowing to:
+}
-      (+) Configure channels.
-      (+) Set the specified data holding register value for DAC channel.
+/**
+  * @brief  DMA underrun DAC callback for channel1.
-@endverbatim
+  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
-  * @{
+  *         the configuration information for the specified DAC.
-  */
+  * @retval None
+  */
-/**
+__weak void HAL_DAC_DMAUnderrunCallbackCh1(DAC_HandleTypeDef *hdac)
-  * @brief  Returns the last data output value of the selected DAC channel.
+{
-  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
+  /* Prevent unused argument(s) compilation warning */
-  *         the configuration information for the specified DAC.
+  UNUSED(hdac);
-  * @param  Channel The selected DAC channel.
-  *          This parameter can be one of the following values:
+  /* NOTE : This function should not be modified, when the callback is needed,
-  *            @arg DAC_CHANNEL_1: DAC Channel1 selected
+            the HAL_DAC_DMAUnderrunCallbackCh1 could be implemented in the user file
-  *            @arg DAC_CHANNEL_2: DAC Channel2 selected
+   */
-  * @retval The selected DAC channel data output value.
+}
-  */
-uint32_t HAL_DAC_GetValue(DAC_HandleTypeDef *hdac, uint32_t Channel)
+/**
-{
+  * @}
-  uint32_t result;
+  */
-  /* Check the parameters */
+/** @defgroup DAC_Exported_Functions_Group3 Peripheral Control functions
-  assert_param(IS_DAC_CHANNEL(Channel));
+  *  @brief    Peripheral Control functions
+  *
-  if (Channel == DAC_CHANNEL_1)
+@verbatim
-  {
+  ==============================================================================
-    result = hdac->Instance->DOR1;
+             ##### Peripheral Control functions #####
-  }
+  ==============================================================================
+    [..]  This section provides functions allowing to:
-  else
+      (+) Configure channels.
-  {
+      (+) Set the specified data holding register value for DAC channel.
-    result = hdac->Instance->DOR2;
-  }
+@endverbatim
+  * @{
-  /* Returns the DAC channel data output register value */
+  */
-  return result;
-}
+/**
+  * @brief  Returns the last data output value of the selected DAC channel.
-/**
+  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
-  * @brief  Configures the selected DAC channel.
+  *         the configuration information for the specified DAC.
-  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
+  * @param  Channel The selected DAC channel.
-  *         the configuration information for the specified DAC.
+  *          This parameter can be one of the following values:
-  * @param  sConfig DAC configuration structure.
+  *            @arg DAC_CHANNEL_1: DAC Channel1 selected
-  * @param  Channel The selected DAC channel.
+  *            @arg DAC_CHANNEL_2: DAC Channel2 selected
-  *          This parameter can be one of the following values:
+  * @retval The selected DAC channel data output value.
-  *            @arg DAC_CHANNEL_1: DAC Channel1 selected
+  */
-  *            @arg DAC_CHANNEL_2: DAC Channel2 selected
+uint32_t HAL_DAC_GetValue(const DAC_HandleTypeDef *hdac, uint32_t Channel)
-  * @retval HAL status
+{
-  */
+  uint32_t result;
-HAL_StatusTypeDef HAL_DAC_ConfigChannel(DAC_HandleTypeDef *hdac, DAC_ChannelConfTypeDef *sConfig, uint32_t Channel)
-{
+  /* Check the DAC peripheral handle */
-  uint32_t tmpreg1;
+  if (hdac == NULL)
-  uint32_t tmpreg2;
+  {
+    return HAL_ERROR;
-  /* Check the DAC parameters */
+  }
-  assert_param(IS_DAC_TRIGGER(sConfig->DAC_Trigger));
-  assert_param(IS_DAC_OUTPUT_BUFFER_STATE(sConfig->DAC_OutputBuffer));
+  /* Check the parameters */
   assert_param(IS_DAC_CHANNEL(Channel));
-  /* Process locked */
+  if (Channel == DAC_CHANNEL_1)
-  __HAL_LOCK(hdac);
+  {
+    result = hdac->Instance->DOR1;
-  /* Change DAC state */
+  }
-  hdac->State = HAL_DAC_STATE_BUSY;
+  else
-  /* Get the DAC CR value */
+  {
-  tmpreg1 = hdac->Instance->CR;
+    result = hdac->Instance->DOR2;
-  /* Clear BOFFx, TENx, TSELx, WAVEx and MAMPx bits */
+  }
-  tmpreg1 &= ~(((uint32_t)(DAC_CR_MAMP1 | DAC_CR_WAVE1 | DAC_CR_TSEL1 | DAC_CR_TEN1 | DAC_CR_BOFF1)) << (Channel & 0x10UL));
-  /* Configure for the selected DAC channel: buffer output, trigger */
+  /* Returns the DAC channel data output register value */
-  /* Set TSELx and TENx bits according to DAC_Trigger value */
+  return result;
-  /* Set BOFFx bit according to DAC_OutputBuffer value */
+}
-  tmpreg2 = (sConfig->DAC_Trigger | sConfig->DAC_OutputBuffer);
-  /* Calculate CR register value depending on DAC_Channel */
+/**
-  tmpreg1 |= tmpreg2 << (Channel & 0x10UL);
+  * @brief  Configures the selected DAC channel.
-  /* Write to DAC CR */
+  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
-  hdac->Instance->CR = tmpreg1;
+  *         the configuration information for the specified DAC.
-  /* Disable wave generation */
+  * @param  sConfig DAC configuration structure.
-  CLEAR_BIT(hdac->Instance->CR, (DAC_CR_WAVE1 << (Channel & 0x10UL)));
+  * @param  Channel The selected DAC channel.
+  *          This parameter can be one of the following values:
-  /* Change DAC state */
+  *            @arg DAC_CHANNEL_1: DAC Channel1 selected
-  hdac->State = HAL_DAC_STATE_READY;
+  *            @arg DAC_CHANNEL_2: DAC Channel2 selected
+  * @retval HAL status
-  /* Process unlocked */
+  */
-  __HAL_UNLOCK(hdac);
+HAL_StatusTypeDef HAL_DAC_ConfigChannel(DAC_HandleTypeDef *hdac,
+                                        const DAC_ChannelConfTypeDef *sConfig, uint32_t Channel)
-  /* Return function status */
+{
-  return HAL_OK;
+  HAL_StatusTypeDef status = HAL_OK;
-}
+  uint32_t tmpreg1;
+  uint32_t tmpreg2;
-/**
-  * @}
+  /* Check the DAC peripheral handle and channel configuration struct */
-  */
+  if ((hdac == NULL) || (sConfig == NULL))
+  {
-/** @defgroup DAC_Exported_Functions_Group4 Peripheral State and Errors functions
+    return HAL_ERROR;
-  *  @brief   Peripheral State and Errors functions
+  }
-  *
-@verbatim
+  /* Check the DAC parameters */
-  ==============================================================================
+  assert_param(IS_DAC_TRIGGER(sConfig->DAC_Trigger));
-            ##### Peripheral State and Errors functions #####
+  assert_param(IS_DAC_OUTPUT_BUFFER_STATE(sConfig->DAC_OutputBuffer));
-  ==============================================================================
+  assert_param(IS_DAC_CHANNEL(Channel));
-    [..]
-    This subsection provides functions allowing to
+  /* Process locked */
-      (+) Check the DAC state.
+  __HAL_LOCK(hdac);
-      (+) Check the DAC Errors.
+  /* Change DAC state */
-@endverbatim
+  hdac->State = HAL_DAC_STATE_BUSY;
-  * @{
-  */
+  /* Get the DAC CR value */
+  tmpreg1 = hdac->Instance->CR;
-/**
+  /* Clear BOFFx, TENx, TSELx, WAVEx and MAMPx bits */
-  * @brief  return the DAC handle state
+  tmpreg1 &= ~(((uint32_t)(DAC_CR_MAMP1 | DAC_CR_WAVE1 | DAC_CR_TSEL1 | DAC_CR_TEN1 | DAC_CR_BOFF1))
-  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
+               << (Channel & 0x10UL));
-  *         the configuration information for the specified DAC.
+  /* Configure for the selected DAC channel: buffer output, trigger */
-  * @retval HAL state
+  /* Set TSELx and TENx bits according to DAC_Trigger value */
-  */
+  /* Set BOFFx bit according to DAC_OutputBuffer value */
-HAL_DAC_StateTypeDef HAL_DAC_GetState(DAC_HandleTypeDef *hdac)
+  tmpreg2 = (sConfig->DAC_Trigger | sConfig->DAC_OutputBuffer);
-{
+  /* Calculate CR register value depending on DAC_Channel */
-  /* Return DAC handle state */
+  tmpreg1 |= tmpreg2 << (Channel & 0x10UL);
-  return hdac->State;
+  /* Write to DAC CR */
-}
+  hdac->Instance->CR = tmpreg1;
+  /* Disable wave generation */
+  CLEAR_BIT(hdac->Instance->CR, (DAC_CR_WAVE1 << (Channel & 0x10UL)));
-/**
-  * @brief  Return the DAC error code
+  /* Change DAC state */
-  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
+  hdac->State = HAL_DAC_STATE_READY;
-  *         the configuration information for the specified DAC.
-  * @retval DAC Error Code
+  /* Process unlocked */
-  */
+  __HAL_UNLOCK(hdac);
-uint32_t HAL_DAC_GetError(DAC_HandleTypeDef *hdac)
-{
+  /* Return function status */
-  return hdac->ErrorCode;
+  return status;
 }
 /**
   * @}
   */
-/**
+/** @defgroup DAC_Exported_Functions_Group4 Peripheral State and Errors functions
-  * @}
+  *  @brief   Peripheral State and Errors functions
-  */
+  *
+@verbatim
-/** @addtogroup DAC_Exported_Functions
+  ==============================================================================
-  * @{
+            ##### Peripheral State and Errors functions #####
-  */
+  ==============================================================================
+    [..]
-/** @addtogroup DAC_Exported_Functions_Group1
+    This subsection provides functions allowing to
-  * @{
+      (+) Check the DAC state.
-  */
+      (+) Check the DAC Errors.
-#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
-/**
+@endverbatim
-  * @brief  Register a User DAC Callback
+  * @{
-  *         To be used instead of the weak (surcharged) predefined callback
+  */
-  * @param  hdac DAC handle
-  * @param  CallbackID ID of the callback to be registered
+/**
-  *         This parameter can be one of the following values:
+  * @brief  return the DAC handle state
-  *          @arg @ref HAL_DAC_ERROR_INVALID_CALLBACK   DAC Error Callback ID
+  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
-  *          @arg @ref HAL_DAC_CH1_COMPLETE_CB_ID       DAC CH1 Complete Callback ID
+  *         the configuration information for the specified DAC.
-  *          @arg @ref HAL_DAC_CH1_HALF_COMPLETE_CB_ID  DAC CH1 Half Complete Callback ID
+  * @retval HAL state
-  *          @arg @ref HAL_DAC_CH1_ERROR_ID             DAC CH1 Error Callback ID
+  */
-  *          @arg @ref HAL_DAC_CH1_UNDERRUN_CB_ID       DAC CH1 UnderRun Callback ID
+HAL_DAC_StateTypeDef HAL_DAC_GetState(const DAC_HandleTypeDef *hdac)
-  *          @arg @ref HAL_DAC_CH2_COMPLETE_CB_ID       DAC CH2 Complete Callback ID
+{
-  *          @arg @ref HAL_DAC_CH2_HALF_COMPLETE_CB_ID  DAC CH2 Half Complete Callback ID
+  /* Return DAC handle state */
-  *          @arg @ref HAL_DAC_CH2_ERROR_ID             DAC CH2 Error Callback ID
+  return hdac->State;
-  *          @arg @ref HAL_DAC_CH2_UNDERRUN_CB_ID       DAC CH2 UnderRun Callback ID
+}
-  *          @arg @ref HAL_DAC_MSPINIT_CB_ID            DAC MSP Init Callback ID
-  *          @arg @ref HAL_DAC_MSPDEINIT_CB_ID          DAC MSP DeInit Callback ID
-  *
+/**
-  * @param  pCallback pointer to the Callback function
+  * @brief  Return the DAC error code
-  * @retval status
+  * @param  hdac pointer to a DAC_HandleTypeDef structure that contains
-  */
+  *         the configuration information for the specified DAC.
-HAL_StatusTypeDef HAL_DAC_RegisterCallback(DAC_HandleTypeDef *hdac, HAL_DAC_CallbackIDTypeDef CallbackID,
+  * @retval DAC Error Code
-                                           pDAC_CallbackTypeDef pCallback)
+  */
-{
+uint32_t HAL_DAC_GetError(const DAC_HandleTypeDef *hdac)
-  HAL_StatusTypeDef status = HAL_OK;
+{
+  return hdac->ErrorCode;
-  if (pCallback == NULL)
+}
-  {
-    /* Update the error code */
+/**
-    hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
+  * @}
-    return HAL_ERROR;
+  */
-  }
+/**
-  /* Process locked */
+  * @}
-  __HAL_LOCK(hdac);
+  */
-  if (hdac->State == HAL_DAC_STATE_READY)
+/** @addtogroup DAC_Exported_Functions
-  {
+  * @{
-    switch (CallbackID)
+  */
-    {
-      case HAL_DAC_CH1_COMPLETE_CB_ID :
+/** @addtogroup DAC_Exported_Functions_Group1
-        hdac->ConvCpltCallbackCh1 = pCallback;
+  * @{
-        break;
+  */
-      case HAL_DAC_CH1_HALF_COMPLETE_CB_ID :
+#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
-        hdac->ConvHalfCpltCallbackCh1 = pCallback;
+/**
-        break;
+  * @brief  Register a User DAC Callback
-      case HAL_DAC_CH1_ERROR_ID :
+  *         To be used instead of the weak (overridden) predefined callback
-        hdac->ErrorCallbackCh1 = pCallback;
+  * @note   The HAL_DAC_RegisterCallback() may be called before HAL_DAC_Init() in HAL_DAC_STATE_RESET to register
-        break;
+  *         callbacks for HAL_DAC_MSPINIT_CB_ID and HAL_DAC_MSPDEINIT_CB_ID
-      case HAL_DAC_CH1_UNDERRUN_CB_ID :
+  * @param  hdac DAC handle
-        hdac->DMAUnderrunCallbackCh1 = pCallback;
+  * @param  CallbackID ID of the callback to be registered
-        break;
+  *         This parameter can be one of the following values:
+  *          @arg @ref HAL_DAC_ERROR_INVALID_CALLBACK   DAC Error Callback ID
-      case HAL_DAC_CH2_COMPLETE_CB_ID :
+  *          @arg @ref HAL_DAC_CH1_COMPLETE_CB_ID       DAC CH1 Complete Callback ID
-        hdac->ConvCpltCallbackCh2 = pCallback;
+  *          @arg @ref HAL_DAC_CH1_HALF_COMPLETE_CB_ID  DAC CH1 Half Complete Callback ID
-        break;
+  *          @arg @ref HAL_DAC_CH1_ERROR_ID             DAC CH1 Error Callback ID
-      case HAL_DAC_CH2_HALF_COMPLETE_CB_ID :
+  *          @arg @ref HAL_DAC_CH1_UNDERRUN_CB_ID       DAC CH1 UnderRun Callback ID
-        hdac->ConvHalfCpltCallbackCh2 = pCallback;
+  *          @arg @ref HAL_DAC_CH2_COMPLETE_CB_ID       DAC CH2 Complete Callback ID
-        break;
+  *          @arg @ref HAL_DAC_CH2_HALF_COMPLETE_CB_ID  DAC CH2 Half Complete Callback ID
-      case HAL_DAC_CH2_ERROR_ID :
+  *          @arg @ref HAL_DAC_CH2_ERROR_ID             DAC CH2 Error Callback ID
-        hdac->ErrorCallbackCh2 = pCallback;
+  *          @arg @ref HAL_DAC_CH2_UNDERRUN_CB_ID       DAC CH2 UnderRun Callback ID
-        break;
+  *          @arg @ref HAL_DAC_MSPINIT_CB_ID            DAC MSP Init Callback ID
-      case HAL_DAC_CH2_UNDERRUN_CB_ID :
+  *          @arg @ref HAL_DAC_MSPDEINIT_CB_ID          DAC MSP DeInit Callback ID
-        hdac->DMAUnderrunCallbackCh2 = pCallback;
+  *
-        break;
+  * @param  pCallback pointer to the Callback function
+  * @retval status
-      case HAL_DAC_MSPINIT_CB_ID :
+  */
-        hdac->MspInitCallback = pCallback;
+HAL_StatusTypeDef HAL_DAC_RegisterCallback(DAC_HandleTypeDef *hdac, HAL_DAC_CallbackIDTypeDef CallbackID,
-        break;
+                                           pDAC_CallbackTypeDef pCallback)
-      case HAL_DAC_MSPDEINIT_CB_ID :
+{
-        hdac->MspDeInitCallback = pCallback;
+  HAL_StatusTypeDef status = HAL_OK;
-        break;
-      default :
+  /* Check the DAC peripheral handle */
-        /* Update the error code */
+  if (hdac == NULL)
-        hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
+  {
-        /* update return status */
+    return HAL_ERROR;
-        status =  HAL_ERROR;
+  }
-        break;
-    }
+  if (pCallback == NULL)
-  }
+  {
-  else if (hdac->State == HAL_DAC_STATE_RESET)
+    /* Update the error code */
-  {
+    hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
-    switch (CallbackID)
+    return HAL_ERROR;
-    {
+  }
-      case HAL_DAC_MSPINIT_CB_ID :
-        hdac->MspInitCallback = pCallback;
+  if (hdac->State == HAL_DAC_STATE_READY)
-        break;
+  {
-      case HAL_DAC_MSPDEINIT_CB_ID :
+    switch (CallbackID)
-        hdac->MspDeInitCallback = pCallback;
+    {
-        break;
+      case HAL_DAC_CH1_COMPLETE_CB_ID :
-      default :
+        hdac->ConvCpltCallbackCh1 = pCallback;
-        /* Update the error code */
+        break;
-        hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
+      case HAL_DAC_CH1_HALF_COMPLETE_CB_ID :
-        /* update return status */
+        hdac->ConvHalfCpltCallbackCh1 = pCallback;
-        status =  HAL_ERROR;
+        break;
-        break;
+      case HAL_DAC_CH1_ERROR_ID :
-    }
+        hdac->ErrorCallbackCh1 = pCallback;
-  }
+        break;
-  else
+      case HAL_DAC_CH1_UNDERRUN_CB_ID :
-  {
+        hdac->DMAUnderrunCallbackCh1 = pCallback;
-    /* Update the error code */
+        break;
-    hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
-    /* update return status */
+      case HAL_DAC_CH2_COMPLETE_CB_ID :
-    status =  HAL_ERROR;
+        hdac->ConvCpltCallbackCh2 = pCallback;
-  }
+        break;
+      case HAL_DAC_CH2_HALF_COMPLETE_CB_ID :
-  /* Release Lock */
+        hdac->ConvHalfCpltCallbackCh2 = pCallback;
-  __HAL_UNLOCK(hdac);
+        break;
-  return status;
+      case HAL_DAC_CH2_ERROR_ID :
-}
+        hdac->ErrorCallbackCh2 = pCallback;
+        break;
-/**
+      case HAL_DAC_CH2_UNDERRUN_CB_ID :
-  * @brief  Unregister a User DAC Callback
+        hdac->DMAUnderrunCallbackCh2 = pCallback;
-  *         DAC Callback is redirected to the weak (surcharged) predefined callback
+        break;
-  * @param  hdac DAC handle
-  * @param  CallbackID ID of the callback to be unregistered
+      case HAL_DAC_MSPINIT_CB_ID :
-  *         This parameter can be one of the following values:
+        hdac->MspInitCallback = pCallback;
-  *          @arg @ref HAL_DAC_CH1_COMPLETE_CB_ID          DAC CH1 transfer Complete Callback ID
+        break;
-  *          @arg @ref HAL_DAC_CH1_HALF_COMPLETE_CB_ID     DAC CH1 Half Complete Callback ID
+      case HAL_DAC_MSPDEINIT_CB_ID :
-  *          @arg @ref HAL_DAC_CH1_ERROR_ID                DAC CH1 Error Callback ID
+        hdac->MspDeInitCallback = pCallback;
-  *          @arg @ref HAL_DAC_CH1_UNDERRUN_CB_ID          DAC CH1 UnderRun Callback ID
+        break;
-  *          @arg @ref HAL_DAC_CH2_COMPLETE_CB_ID          DAC CH2 Complete Callback ID
+      default :
-  *          @arg @ref HAL_DAC_CH2_HALF_COMPLETE_CB_ID     DAC CH2 Half Complete Callback ID
+        /* Update the error code */
-  *          @arg @ref HAL_DAC_CH2_ERROR_ID                DAC CH2 Error Callback ID
+        hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
-  *          @arg @ref HAL_DAC_CH2_UNDERRUN_CB_ID          DAC CH2 UnderRun Callback ID
+        /* update return status */
-  *          @arg @ref HAL_DAC_MSPINIT_CB_ID               DAC MSP Init Callback ID
+        status =  HAL_ERROR;
-  *          @arg @ref HAL_DAC_MSPDEINIT_CB_ID             DAC MSP DeInit Callback ID
+        break;
-  *          @arg @ref HAL_DAC_ALL_CB_ID                   DAC All callbacks
+    }
-  * @retval status
+  }
-  */
+  else if (hdac->State == HAL_DAC_STATE_RESET)
-HAL_StatusTypeDef HAL_DAC_UnRegisterCallback(DAC_HandleTypeDef *hdac, HAL_DAC_CallbackIDTypeDef CallbackID)
+  {
-{
+    switch (CallbackID)
-  HAL_StatusTypeDef status = HAL_OK;
+    {
+      case HAL_DAC_MSPINIT_CB_ID :
-  /* Process locked */
+        hdac->MspInitCallback = pCallback;
-  __HAL_LOCK(hdac);
+        break;
+      case HAL_DAC_MSPDEINIT_CB_ID :
-  if (hdac->State == HAL_DAC_STATE_READY)
+        hdac->MspDeInitCallback = pCallback;
-  {
+        break;
-    switch (CallbackID)
+      default :
-    {
+        /* Update the error code */
-      case HAL_DAC_CH1_COMPLETE_CB_ID :
+        hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
-        hdac->ConvCpltCallbackCh1 = HAL_DAC_ConvCpltCallbackCh1;
+        /* update return status */
-        break;
+        status =  HAL_ERROR;
-      case HAL_DAC_CH1_HALF_COMPLETE_CB_ID :
+        break;
-        hdac->ConvHalfCpltCallbackCh1 = HAL_DAC_ConvHalfCpltCallbackCh1;
+    }
-        break;
+  }
-      case HAL_DAC_CH1_ERROR_ID :
+  else
-        hdac->ErrorCallbackCh1 = HAL_DAC_ErrorCallbackCh1;
+  {
-        break;
+    /* Update the error code */
-      case HAL_DAC_CH1_UNDERRUN_CB_ID :
+    hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
-        hdac->DMAUnderrunCallbackCh1 = HAL_DAC_DMAUnderrunCallbackCh1;
+    /* update return status */
-        break;
+    status =  HAL_ERROR;
+  }
-      case HAL_DAC_CH2_COMPLETE_CB_ID :
-        hdac->ConvCpltCallbackCh2 = HAL_DACEx_ConvCpltCallbackCh2;
+  return status;
-        break;
+}
-      case HAL_DAC_CH2_HALF_COMPLETE_CB_ID :
-        hdac->ConvHalfCpltCallbackCh2 = HAL_DACEx_ConvHalfCpltCallbackCh2;
+/**
-        break;
+  * @brief  Unregister a User DAC Callback
-      case HAL_DAC_CH2_ERROR_ID :
+  *         DAC Callback is redirected to the weak (overridden) predefined callback
-        hdac->ErrorCallbackCh2 = HAL_DACEx_ErrorCallbackCh2;
+  * @note   The HAL_DAC_UnRegisterCallback() may be called before HAL_DAC_Init() in HAL_DAC_STATE_RESET to un-register
-        break;
+  *         callbacks for HAL_DAC_MSPINIT_CB_ID and HAL_DAC_MSPDEINIT_CB_ID
-      case HAL_DAC_CH2_UNDERRUN_CB_ID :
+  * @param  hdac DAC handle
-        hdac->DMAUnderrunCallbackCh2 = HAL_DACEx_DMAUnderrunCallbackCh2;
+  * @param  CallbackID ID of the callback to be unregistered
-        break;
+  *         This parameter can be one of the following values:
+  *          @arg @ref HAL_DAC_CH1_COMPLETE_CB_ID          DAC CH1 transfer Complete Callback ID
-      case HAL_DAC_MSPINIT_CB_ID :
+  *          @arg @ref HAL_DAC_CH1_HALF_COMPLETE_CB_ID     DAC CH1 Half Complete Callback ID
-        hdac->MspInitCallback = HAL_DAC_MspInit;
+  *          @arg @ref HAL_DAC_CH1_ERROR_ID                DAC CH1 Error Callback ID
-        break;
+  *          @arg @ref HAL_DAC_CH1_UNDERRUN_CB_ID          DAC CH1 UnderRun Callback ID
-      case HAL_DAC_MSPDEINIT_CB_ID :
+  *          @arg @ref HAL_DAC_CH2_COMPLETE_CB_ID          DAC CH2 Complete Callback ID
-        hdac->MspDeInitCallback = HAL_DAC_MspDeInit;
+  *          @arg @ref HAL_DAC_CH2_HALF_COMPLETE_CB_ID     DAC CH2 Half Complete Callback ID
-        break;
+  *          @arg @ref HAL_DAC_CH2_ERROR_ID                DAC CH2 Error Callback ID
-      case HAL_DAC_ALL_CB_ID :
+  *          @arg @ref HAL_DAC_CH2_UNDERRUN_CB_ID          DAC CH2 UnderRun Callback ID
-        hdac->ConvCpltCallbackCh1 = HAL_DAC_ConvCpltCallbackCh1;
+  *          @arg @ref HAL_DAC_MSPINIT_CB_ID               DAC MSP Init Callback ID
-        hdac->ConvHalfCpltCallbackCh1 = HAL_DAC_ConvHalfCpltCallbackCh1;
+  *          @arg @ref HAL_DAC_MSPDEINIT_CB_ID             DAC MSP DeInit Callback ID
-        hdac->ErrorCallbackCh1 = HAL_DAC_ErrorCallbackCh1;
+  *          @arg @ref HAL_DAC_ALL_CB_ID                   DAC All callbacks
-        hdac->DMAUnderrunCallbackCh1 = HAL_DAC_DMAUnderrunCallbackCh1;
+  * @retval status
+  */
-        hdac->ConvCpltCallbackCh2 = HAL_DACEx_ConvCpltCallbackCh2;
+HAL_StatusTypeDef HAL_DAC_UnRegisterCallback(DAC_HandleTypeDef *hdac, HAL_DAC_CallbackIDTypeDef CallbackID)
-        hdac->ConvHalfCpltCallbackCh2 = HAL_DACEx_ConvHalfCpltCallbackCh2;
+{
-        hdac->ErrorCallbackCh2 = HAL_DACEx_ErrorCallbackCh2;
+  HAL_StatusTypeDef status = HAL_OK;
-        hdac->DMAUnderrunCallbackCh2 = HAL_DACEx_DMAUnderrunCallbackCh2;
+  /* Check the DAC peripheral handle */
-        hdac->MspInitCallback = HAL_DAC_MspInit;
+  if (hdac == NULL)
-        hdac->MspDeInitCallback = HAL_DAC_MspDeInit;
+  {
-        break;
+    return HAL_ERROR;
-      default :
+  }
-        /* Update the error code */
-        hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
+  if (hdac->State == HAL_DAC_STATE_READY)
-        /* update return status */
+  {
-        status =  HAL_ERROR;
+    switch (CallbackID)
-        break;
+    {
-    }
+      case HAL_DAC_CH1_COMPLETE_CB_ID :
-  }
+        hdac->ConvCpltCallbackCh1 = HAL_DAC_ConvCpltCallbackCh1;
-  else if (hdac->State == HAL_DAC_STATE_RESET)
+        break;
-  {
+      case HAL_DAC_CH1_HALF_COMPLETE_CB_ID :
-    switch (CallbackID)
+        hdac->ConvHalfCpltCallbackCh1 = HAL_DAC_ConvHalfCpltCallbackCh1;
-    {
+        break;
-      case HAL_DAC_MSPINIT_CB_ID :
+      case HAL_DAC_CH1_ERROR_ID :
-        hdac->MspInitCallback = HAL_DAC_MspInit;
+        hdac->ErrorCallbackCh1 = HAL_DAC_ErrorCallbackCh1;
         break;
-      case HAL_DAC_MSPDEINIT_CB_ID :
+      case HAL_DAC_CH1_UNDERRUN_CB_ID :
-        hdac->MspDeInitCallback = HAL_DAC_MspDeInit;
+        hdac->DMAUnderrunCallbackCh1 = HAL_DAC_DMAUnderrunCallbackCh1;
         break;
-      default :
-        /* Update the error code */
+      case HAL_DAC_CH2_COMPLETE_CB_ID :
-        hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
+        hdac->ConvCpltCallbackCh2 = HAL_DACEx_ConvCpltCallbackCh2;
-        /* update return status */
+        break;
-        status =  HAL_ERROR;
+      case HAL_DAC_CH2_HALF_COMPLETE_CB_ID :
-        break;
+        hdac->ConvHalfCpltCallbackCh2 = HAL_DACEx_ConvHalfCpltCallbackCh2;
-    }
+        break;
-  }
+      case HAL_DAC_CH2_ERROR_ID :
-  else
+        hdac->ErrorCallbackCh2 = HAL_DACEx_ErrorCallbackCh2;
-  {
+        break;
-    /* Update the error code */
+      case HAL_DAC_CH2_UNDERRUN_CB_ID :
-    hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
+        hdac->DMAUnderrunCallbackCh2 = HAL_DACEx_DMAUnderrunCallbackCh2;
-    /* update return status */
+        break;
-    status =  HAL_ERROR;
-  }
+      case HAL_DAC_MSPINIT_CB_ID :
+        hdac->MspInitCallback = HAL_DAC_MspInit;
-  /* Release Lock */
+        break;
-  __HAL_UNLOCK(hdac);
+      case HAL_DAC_MSPDEINIT_CB_ID :
-  return status;
+        hdac->MspDeInitCallback = HAL_DAC_MspDeInit;
-}
+        break;
-#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
+      case HAL_DAC_ALL_CB_ID :
+        hdac->ConvCpltCallbackCh1 = HAL_DAC_ConvCpltCallbackCh1;
-/**
+        hdac->ConvHalfCpltCallbackCh1 = HAL_DAC_ConvHalfCpltCallbackCh1;
-  * @}
+        hdac->ErrorCallbackCh1 = HAL_DAC_ErrorCallbackCh1;
-  */
+        hdac->DMAUnderrunCallbackCh1 = HAL_DAC_DMAUnderrunCallbackCh1;
-/**
+        hdac->ConvCpltCallbackCh2 = HAL_DACEx_ConvCpltCallbackCh2;
-  * @}
+        hdac->ConvHalfCpltCallbackCh2 = HAL_DACEx_ConvHalfCpltCallbackCh2;
-  */
+        hdac->ErrorCallbackCh2 = HAL_DACEx_ErrorCallbackCh2;
+        hdac->DMAUnderrunCallbackCh2 = HAL_DACEx_DMAUnderrunCallbackCh2;
-/** @addtogroup DAC_Private_Functions
-  * @{
+        hdac->MspInitCallback = HAL_DAC_MspInit;
-  */
+        hdac->MspDeInitCallback = HAL_DAC_MspDeInit;
+        break;
-/**
+      default :
-  * @brief  DMA conversion complete callback.
+        /* Update the error code */
-  * @param  hdma pointer to a DMA_HandleTypeDef structure that contains
+        hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
-  *                the configuration information for the specified DMA module.
+        /* update return status */
-  * @retval None
+        status =  HAL_ERROR;
-  */
+        break;
-void DAC_DMAConvCpltCh1(DMA_HandleTypeDef *hdma)
+    }
-{
+  }
-  DAC_HandleTypeDef *hdac = (DAC_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  else if (hdac->State == HAL_DAC_STATE_RESET)
+  {
-#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
+    switch (CallbackID)
-  hdac->ConvCpltCallbackCh1(hdac);
+    {
-#else
+      case HAL_DAC_MSPINIT_CB_ID :
-  HAL_DAC_ConvCpltCallbackCh1(hdac);
+        hdac->MspInitCallback = HAL_DAC_MspInit;
-#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
+        break;
+      case HAL_DAC_MSPDEINIT_CB_ID :
-  hdac->State = HAL_DAC_STATE_READY;
+        hdac->MspDeInitCallback = HAL_DAC_MspDeInit;
-}
+        break;
+      default :
-/**
+        /* Update the error code */
-  * @brief  DMA half transfer complete callback.
+        hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
-  * @param  hdma pointer to a DMA_HandleTypeDef structure that contains
+        /* update return status */
-  *                the configuration information for the specified DMA module.
+        status =  HAL_ERROR;
-  * @retval None
+        break;
-  */
+    }
-void DAC_DMAHalfConvCpltCh1(DMA_HandleTypeDef *hdma)
+  }
-{
+  else
-  DAC_HandleTypeDef *hdac = (DAC_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  {
-  /* Conversion complete callback */
+    /* Update the error code */
-#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
+    hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
-  hdac->ConvHalfCpltCallbackCh1(hdac);
+    /* update return status */
-#else
+    status =  HAL_ERROR;
-  HAL_DAC_ConvHalfCpltCallbackCh1(hdac);
+  }
-#endif  /* USE_HAL_DAC_REGISTER_CALLBACKS */
-}
+  return status;
+}
-/**
+#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
-  * @brief  DMA error callback
-  * @param  hdma pointer to a DMA_HandleTypeDef structure that contains
+/**
-  *                the configuration information for the specified DMA module.
+  * @}
-  * @retval None
+  */
-  */
-void DAC_DMAErrorCh1(DMA_HandleTypeDef *hdma)
+/**
-{
+  * @}
-  DAC_HandleTypeDef *hdac = (DAC_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  */
-  /* Set DAC error code to DMA error */
+/** @addtogroup DAC_Private_Functions
-  hdac->ErrorCode |= HAL_DAC_ERROR_DMA;
+  * @{
+  */
-#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
-  hdac->ErrorCallbackCh1(hdac);
+/**
-#else
+  * @brief  DMA conversion complete callback.
-  HAL_DAC_ErrorCallbackCh1(hdac);
+  * @param  hdma pointer to a DMA_HandleTypeDef structure that contains
-#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
+  *                the configuration information for the specified DMA module.
+  * @retval None
-  hdac->State = HAL_DAC_STATE_READY;
+  */
-}
+void DAC_DMAConvCpltCh1(DMA_HandleTypeDef *hdma)
+{
-/**
+  DAC_HandleTypeDef *hdac = (DAC_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-  * @}
-  */
+#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
+  hdac->ConvCpltCallbackCh1(hdac);
-/**
+#else
-  * @}
+  HAL_DAC_ConvCpltCallbackCh1(hdac);
-  */
+#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
-#endif /* DAC */
+  hdac->State = HAL_DAC_STATE_READY;
+}
-#endif /* HAL_DAC_MODULE_ENABLED */
+/**
-/**
+  * @brief  DMA half transfer complete callback.
-  * @}
+  * @param  hdma pointer to a DMA_HandleTypeDef structure that contains
-  */
+  *                the configuration information for the specified DMA module.
+  * @retval None
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+  */
+void DAC_DMAHalfConvCpltCh1(DMA_HandleTypeDef *hdma)
+{
+  DAC_HandleTypeDef *hdac = (DAC_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  /* Conversion complete callback */
+#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
+  hdac->ConvHalfCpltCallbackCh1(hdac);
+#else
+  HAL_DAC_ConvHalfCpltCallbackCh1(hdac);
+#endif  /* USE_HAL_DAC_REGISTER_CALLBACKS */
+}
+/**
+  * @brief  DMA error callback
+  * @param  hdma pointer to a DMA_HandleTypeDef structure that contains
+  *                the configuration information for the specified DMA module.
+  * @retval None
+  */
+void DAC_DMAErrorCh1(DMA_HandleTypeDef *hdma)
+{
+  DAC_HandleTypeDef *hdac = (DAC_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  /* Set DAC error code to DMA error */
+  hdac->ErrorCode |= HAL_DAC_ERROR_DMA;
+#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
+  hdac->ErrorCallbackCh1(hdac);
+#else
+  HAL_DAC_ErrorCallbackCh1(hdac);
+#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
+  hdac->State = HAL_DAC_STATE_READY;
+}
+/**
+  * @}
+  */
+/**
+  * @}
+  */
+#endif /* DAC */
+#endif /* HAL_DAC_MODULE_ENABLED */
+/**
+  * @}
+  */

Subversion Repositories canSerial

(root)/trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_dac.c – Rev 2 → 3