WebSVN – DashDisplay – Blame – /branches/Dashboard_L152_210623/Drivers/STM32L1xx_HAL_Driver/Src/stm32l1xx_hal_dac.c

Rev	Author	Line No.	Line
56	mjames	1	/**
		2	******************************************************************************
		3	* @file stm32l1xx_hal_dac.c
		4	* @author MCD Application Team
		5	* @brief DAC HAL module driver.
		6	* This file provides firmware functions to manage the following
		7	* functionalities of the Digital to Analog Converter (DAC) peripheral:
		8	* + Initialization and de-initialization functions
		9	* + IO operation functions
		10	* + Peripheral Control functions
		11	* + Peripheral State and Errors functions
		12	*
		13	*
		14	@verbatim
		15	==============================================================================
		16	##### DAC Peripheral features #####
		17	==============================================================================
		18	[..]
		19	* DAC Channels *
		20	====================
		21	[..]
		22	STM32L1 devices integrate two 12-bit Digital Analog Converters
		23
		24	The 2 converters (i.e. channel1 & channel2)
		25	can be used independently or simultaneously (dual mode):
		26	(#) DAC channel1 with DAC_OUT1 (PA4) as output or connected to on-chip
		27	peripherals (ex. timers).
		28	(#) DAC channel2 with DAC_OUT2 (PA5) as output or connected to on-chip
		29	peripherals (ex. timers).
		30
		31	* DAC Triggers *
		32	====================
		33	[..]
		34	Digital to Analog conversion can be non-triggered using DAC_TRIGGER_NONE
		35	and DAC_OUT1/DAC_OUT2 is available once writing to DHRx register.
		36	[..]
		37	Digital to Analog conversion can be triggered by:
		38	(#) External event: EXTI Line 9 (any GPIOx_PIN_9) using DAC_TRIGGER_EXT_IT9.
		39	The used pin (GPIOx_PIN_9) must be configured in input mode.
		40
		41	(#) Timers TRGO: TIM2, TIM4, TIM6, TIM7, TIM9
		42	(DAC_TRIGGER_T2_TRGO, DAC_TRIGGER_T4_TRGO...)
		43
		44	(#) Software using DAC_TRIGGER_SOFTWARE
		45
		46	* DAC Buffer mode feature *
		47	===============================
		48	[..]
		49	Each DAC channel integrates an output buffer that can be used to
		50	reduce the output impedance, and to drive external loads directly
		51	without having to add an external operational amplifier.
		52	To enable, the output buffer use
		53	sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
		54	[..]
		55	(@) Refer to the device datasheet for more details about output
		56	impedance value with and without output buffer.
		57
		58	* GPIO configurations guidelines *
		59	=====================
		60	[..]
		61	When a DAC channel is used (ex channel1 on PA4) and the other is not
		62	(ex channel2 on PA5 is configured in Analog and disabled).
		63	Channel1 may disturb channel2 as coupling effect.
		64	Note that there is no coupling on channel2 as soon as channel2 is turned on.
		65	Coupling on adjacent channel could be avoided as follows:
		66	when unused PA5 is configured as INPUT PULL-UP or DOWN.
		67	PA5 is configured in ANALOG just before it is turned on.
		68
		69	* DAC wave generation feature *
		70	===================================
		71	[..]
		72	Both DAC channels can be used to generate
		73	(#) Noise wave
		74	(#) Triangle wave
		75
		76	* DAC data format *
		77	=======================
		78	[..]
		79	The DAC data format can be:
		80	(#) 8-bit right alignment using DAC_ALIGN_8B_R
		81	(#) 12-bit left alignment using DAC_ALIGN_12B_L
		82	(#) 12-bit right alignment using DAC_ALIGN_12B_R
		83
		84	* DAC data value to voltage correspondence *
		85	================================================
		86	[..]
		87	The analog output voltage on each DAC channel pin is determined
		88	by the following equation:
		89	[..]
		90	DAC_OUTx = VREF+ * DOR / 4095
		91	(+) with DOR is the Data Output Register
		92	[..]
61	mjames	93	VREF+ is the input voltage reference (refer to the device datasheet)
56	mjames	94	[..]
		95	e.g. To set DAC_OUT1 to 0.7V, use
		96	(+) Assuming that VREF+ = 3.3V, DAC_OUT1 = (3.3 * 868) / 4095 = 0.7V
		97
		98	* DMA requests *
		99	=====================
		100	[..]
61	mjames	101	A DMA request can be generated when an external trigger (but not a software trigger)
56	mjames	102	occurs if DMA1 requests are enabled using HAL_DAC_Start_DMA().
		103	DMA1 requests are mapped as following:
61	mjames	104	(#) DAC channel1 mapped on (no request on STM32L1XX) / DMA1 channel2
		105	(#) DAC channel2 mapped on (no request on STM32L1XX) / DMA1 channel3
56	mjames	106
		107	[..]
		108	(@) For Dual mode and specific signal (Triangle and noise) generation please
		109	refer to Extended Features Driver description
		110
		111	##### How to use this driver #####
		112	==============================================================================
		113	[..]
		114	(+) DAC APB clock must be enabled to get write access to DAC
		115	registers using HAL_DAC_Init()
		116	(+) Configure DAC_OUTx (DAC_OUT1: PA4, DAC_OUT2: PA5) in analog mode.
		117	(+) Configure the DAC channel using HAL_DAC_ConfigChannel() function.
		118	(+) Enable the DAC channel using HAL_DAC_Start() or HAL_DAC_Start_DMA() functions.
		119
		120
		121	* Polling mode IO operation *
		122	=================================
		123	[..]
		124	(+) Start the DAC peripheral using HAL_DAC_Start()
		125	(+) To read the DAC last data output value, use the HAL_DAC_GetValue() function.
		126	(+) Stop the DAC peripheral using HAL_DAC_Stop()
		127
		128	* DMA mode IO operation *
		129	==============================
		130	[..]
		131	(+) Start the DAC peripheral using HAL_DAC_Start_DMA(), at this stage the user specify the length
		132	of data to be transferred at each end of conversion
		133	First issued trigger will start the conversion of the value previously set by HAL_DAC_SetValue().
		134	(+) At the middle of data transfer HAL_DAC_ConvHalfCpltCallbackCh1() or HAL_DACEx_ConvHalfCpltCallbackCh2()
		135	function is executed and user can add his own code by customization of function pointer
		136	HAL_DAC_ConvHalfCpltCallbackCh1() or HAL_DACEx_ConvHalfCpltCallbackCh2()
		137	(+) At The end of data transfer HAL_DAC_ConvCpltCallbackCh1() or HAL_DACEx_ConvHalfCpltCallbackCh2()
		138	function is executed and user can add his own code by customization of function pointer
		139	HAL_DAC_ConvCpltCallbackCh1() or HAL_DACEx_ConvHalfCpltCallbackCh2()
		140	(+) In case of transfer Error, HAL_DAC_ErrorCallbackCh1() function is executed and user can
		141	add his own code by customization of function pointer HAL_DAC_ErrorCallbackCh1
		142	(+) In case of DMA underrun, DAC interruption triggers and execute internal function HAL_DAC_IRQHandler.
		143	HAL_DAC_DMAUnderrunCallbackCh1() or HAL_DACEx_DMAUnderrunCallbackCh2()
		144	function is executed and user can add his own code by customization of function pointer
		145	HAL_DAC_DMAUnderrunCallbackCh1() or HAL_DACEx_DMAUnderrunCallbackCh2() and
		146	add his own code by customization of function pointer HAL_DAC_ErrorCallbackCh1()
		147	(+) Stop the DAC peripheral using HAL_DAC_Stop_DMA()
		148
		149	* Callback registration *
		150	=============================================
		151	[..]
		152	The compilation define USE_HAL_DAC_REGISTER_CALLBACKS when set to 1
		153	allows the user to configure dynamically the driver callbacks.
		154
		155	Use Functions @ref HAL_DAC_RegisterCallback() to register a user callback,
		156	it allows to register following callbacks:
		157	(+) ConvCpltCallbackCh1 : callback when a half transfer is completed on Ch1.
		158	(+) ConvHalfCpltCallbackCh1 : callback when a transfer is completed on Ch1.
		159	(+) ErrorCallbackCh1 : callback when an error occurs on Ch1.
		160	(+) DMAUnderrunCallbackCh1 : callback when an underrun error occurs on Ch1.
		161	(+) ConvCpltCallbackCh2 : callback when a half transfer is completed on Ch2.
		162	(+) ConvHalfCpltCallbackCh2 : callback when a transfer is completed on Ch2.
		163	(+) ErrorCallbackCh2 : callback when an error occurs on Ch2.
		164	(+) DMAUnderrunCallbackCh2 : callback when an underrun error occurs on Ch2.
		165	(+) MspInitCallback : DAC MspInit.
		166	(+) MspDeInitCallback : DAC MspdeInit.
		167	This function takes as parameters the HAL peripheral handle, the Callback ID
		168	and a pointer to the user callback function.
		169
		170	Use function @ref HAL_DAC_UnRegisterCallback() to reset a callback to the default
		171	weak (surcharged) function. It allows to reset following callbacks:
		172	(+) ConvCpltCallbackCh1 : callback when a half transfer is completed on Ch1.
		173	(+) ConvHalfCpltCallbackCh1 : callback when a transfer is completed on Ch1.
		174	(+) ErrorCallbackCh1 : callback when an error occurs on Ch1.
		175	(+) DMAUnderrunCallbackCh1 : callback when an underrun error occurs on Ch1.
		176	(+) ConvCpltCallbackCh2 : callback when a half transfer is completed on Ch2.
		177	(+) ConvHalfCpltCallbackCh2 : callback when a transfer is completed on Ch2.
		178	(+) ErrorCallbackCh2 : callback when an error occurs on Ch2.
		179	(+) DMAUnderrunCallbackCh2 : callback when an underrun error occurs on Ch2.
		180	(+) MspInitCallback : DAC MspInit.
		181	(+) MspDeInitCallback : DAC MspdeInit.
		182	(+) All Callbacks
		183	This function) takes as parameters the HAL peripheral handle and the Callback ID.
		184
		185	By default, after the @ref HAL_DAC_Init and if the state is HAL_DAC_STATE_RESET
		186	all callbacks are reset to the corresponding legacy weak (surcharged) functions.
		187	Exception done for MspInit and MspDeInit callbacks that are respectively
		188	reset to the legacy weak (surcharged) functions in the @ref HAL_DAC_Init
		189	and @ref HAL_DAC_DeInit only when these callbacks are null (not registered beforehand).
		190	If not, MspInit or MspDeInit are not null, the @ref HAL_DAC_Init and @ref HAL_DAC_DeInit
		191	keep and use the user MspInit/MspDeInit callbacks (registered beforehand)
		192
		193	Callbacks can be registered/unregistered in READY state only.
		194	Exception done for MspInit/MspDeInit callbacks that can be registered/unregistered
		195	in READY or RESET state, thus registered (user) MspInit/DeInit callbacks can be used
		196	during the Init/DeInit.
		197	In that case first register the MspInit/MspDeInit user callbacks
		198	using @ref HAL_DAC_RegisterCallback before calling @ref HAL_DAC_DeInit
		199	or @ref HAL_DAC_Init function.
		200
		201	When The compilation define USE_HAL_DAC_REGISTER_CALLBACKS is set to 0 or
		202	not defined, the callback registering feature is not available
		203	and weak (surcharged) callbacks are used.
		204
		205	* DAC HAL driver macros list *
		206	=============================================
		207	[..]
		208	Below the list of most used macros in DAC HAL driver.
		209
		210	(+) __HAL_DAC_ENABLE : Enable the DAC peripheral
		211	(+) __HAL_DAC_DISABLE : Disable the DAC peripheral
		212	(+) __HAL_DAC_CLEAR_FLAG: Clear the DAC's pending flags
		213	(+) __HAL_DAC_GET_FLAG: Get the selected DAC's flag status
		214
		215	[..]
		216	(@) You can refer to the DAC HAL driver header file for more useful macros
		217
61	mjames	218	@endverbatim
56	mjames	219	******************************************************************************
		220	* @attention
		221	*
		222	* <h2><center>© Copyright (c) 2016 STMicroelectronics.
		223	* All rights reserved.</center></h2>
		224	*
		225	* This software component is licensed by ST under BSD 3-Clause license,
		226	* the "License"; You may not use this file except in compliance with the
		227	* License. You may obtain a copy of the License at:
		228	* opensource.org/licenses/BSD-3-Clause
		229	*
		230	******************************************************************************
		231	*/
		232
		233	/* Includes ------------------------------------------------------------------*/
		234	#include "stm32l1xx_hal.h"
		235
		236	/** @addtogroup STM32L1xx_HAL_Driver
		237	* @{
		238	*/
		239
		240	#ifdef HAL_DAC_MODULE_ENABLED
		241	#if defined(DAC1)
		242
		243	/** @defgroup DAC DAC
		244	* @brief DAC driver modules
		245	* @{
		246	*/
		247
		248	/* Private typedef -----------------------------------------------------------*/
		249	/* Private define ------------------------------------------------------------*/
		250	/* Private constants ---------------------------------------------------------*/
		251	/* Private macro -------------------------------------------------------------*/
		252	/* Private variables ---------------------------------------------------------*/
		253	/* Private function prototypes -----------------------------------------------*/
		254	/* Exported functions -------------------------------------------------------*/
		255
		256	/** @defgroup DAC_Exported_Functions DAC Exported Functions
		257	* @{
		258	*/
		259
		260	/** @defgroup DAC_Exported_Functions_Group1 Initialization and de-initialization functions
		261	* @brief Initialization and Configuration functions
		262	*
		263	@verbatim
		264	==============================================================================
		265	##### Initialization and de-initialization functions #####
		266	==============================================================================
		267	[..] This section provides functions allowing to:
		268	(+) Initialize and configure the DAC.
		269	(+) De-initialize the DAC.
		270
		271	@endverbatim
		272	* @{
		273	*/
		274
		275	/**
		276	* @brief Initialize the DAC peripheral according to the specified parameters
		277	* in the DAC_InitStruct and initialize the associated handle.
		278	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		279	* the configuration information for the specified DAC.
		280	* @retval HAL status
		281	*/
		282	HAL_StatusTypeDef HAL_DAC_Init(DAC_HandleTypeDef *hdac)
		283	{
		284	/* Check DAC handle */
		285	if (hdac == NULL)
		286	{
		287	return HAL_ERROR;
		288	}
		289	/* Check the parameters */
		290	assert_param(IS_DAC_ALL_INSTANCE(hdac->Instance));
		291
		292	if (hdac->State == HAL_DAC_STATE_RESET)
		293	{
		294	#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
		295	/* Init the DAC Callback settings */
		296	hdac->ConvCpltCallbackCh1 = HAL_DAC_ConvCpltCallbackCh1;
		297	hdac->ConvHalfCpltCallbackCh1 = HAL_DAC_ConvHalfCpltCallbackCh1;
		298	hdac->ErrorCallbackCh1 = HAL_DAC_ErrorCallbackCh1;
		299	hdac->DMAUnderrunCallbackCh1 = HAL_DAC_DMAUnderrunCallbackCh1;
		300
		301	hdac->ConvCpltCallbackCh2 = HAL_DACEx_ConvCpltCallbackCh2;
		302	hdac->ConvHalfCpltCallbackCh2 = HAL_DACEx_ConvHalfCpltCallbackCh2;
		303	hdac->ErrorCallbackCh2 = HAL_DACEx_ErrorCallbackCh2;
		304	hdac->DMAUnderrunCallbackCh2 = HAL_DACEx_DMAUnderrunCallbackCh2;
		305
		306	if (hdac->MspInitCallback == NULL)
		307	{
		308	hdac->MspInitCallback = HAL_DAC_MspInit;
		309	}
		310	#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
		311
		312	/* Allocate lock resource and initialize it */
		313	hdac->Lock = HAL_UNLOCKED;
		314
		315	#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
		316	/* Init the low level hardware */
		317	hdac->MspInitCallback(hdac);
		318	#else
		319	/* Init the low level hardware */
		320	HAL_DAC_MspInit(hdac);
		321	#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
		322	}
		323
		324	/* Initialize the DAC state*/
		325	hdac->State = HAL_DAC_STATE_BUSY;
		326
		327	/* Set DAC error code to none */
		328	hdac->ErrorCode = HAL_DAC_ERROR_NONE;
		329
		330	/* Initialize the DAC state*/
		331	hdac->State = HAL_DAC_STATE_READY;
		332
		333	/* Return function status */
		334	return HAL_OK;
		335	}
		336
		337	/**
		338	* @brief Deinitialize the DAC peripheral registers to their default reset values.
		339	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		340	* the configuration information for the specified DAC.
		341	* @retval HAL status
		342	*/
		343	HAL_StatusTypeDef HAL_DAC_DeInit(DAC_HandleTypeDef *hdac)
		344	{
		345	/* Check DAC handle */
		346	if (hdac == NULL)
		347	{
		348	return HAL_ERROR;
		349	}
		350
		351	/* Check the parameters */
		352	assert_param(IS_DAC_ALL_INSTANCE(hdac->Instance));
		353
		354	/* Change DAC state */
		355	hdac->State = HAL_DAC_STATE_BUSY;
		356
		357	#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
		358	if (hdac->MspDeInitCallback == NULL)
		359	{
		360	hdac->MspDeInitCallback = HAL_DAC_MspDeInit;
		361	}
		362	/* DeInit the low level hardware */
		363	hdac->MspDeInitCallback(hdac);
		364	#else
		365	/* DeInit the low level hardware */
		366	HAL_DAC_MspDeInit(hdac);
		367	#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
		368
		369	/* Set DAC error code to none */
		370	hdac->ErrorCode = HAL_DAC_ERROR_NONE;
		371
		372	/* Change DAC state */
		373	hdac->State = HAL_DAC_STATE_RESET;
		374
		375	/* Release Lock */
		376	__HAL_UNLOCK(hdac);
		377
		378	/* Return function status */
		379	return HAL_OK;
		380	}
		381
		382	/**
		383	* @brief Initialize the DAC MSP.
		384	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		385	* the configuration information for the specified DAC.
		386	* @retval None
		387	*/
		388	__weak void HAL_DAC_MspInit(DAC_HandleTypeDef *hdac)
		389	{
		390	/* Prevent unused argument(s) compilation warning */
		391	UNUSED(hdac);
		392
		393	/* NOTE : This function should not be modified, when the callback is needed,
		394	the HAL_DAC_MspInit could be implemented in the user file
		395	*/
		396	}
		397
		398	/**
		399	* @brief DeInitialize the DAC MSP.
		400	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		401	* the configuration information for the specified DAC.
		402	* @retval None
		403	*/
		404	__weak void HAL_DAC_MspDeInit(DAC_HandleTypeDef *hdac)
		405	{
		406	/* Prevent unused argument(s) compilation warning */
		407	UNUSED(hdac);
		408
		409	/* NOTE : This function should not be modified, when the callback is needed,
		410	the HAL_DAC_MspDeInit could be implemented in the user file
		411	*/
		412	}
		413
		414	/**
		415	* @}
		416	*/
		417
		418	/** @defgroup DAC_Exported_Functions_Group2 IO operation functions
		419	* @brief IO operation functions
		420	*
		421	@verbatim
		422	==============================================================================
		423	##### IO operation functions #####
		424	==============================================================================
		425	[..] This section provides functions allowing to:
		426	(+) Start conversion.
		427	(+) Stop conversion.
		428	(+) Start conversion and enable DMA transfer.
		429	(+) Stop conversion and disable DMA transfer.
		430	(+) Get result of conversion.
		431
		432	@endverbatim
		433	* @{
		434	*/
		435
		436	/**
		437	* @brief Enables DAC and starts conversion of channel.
		438	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		439	* the configuration information for the specified DAC.
		440	* @param Channel The selected DAC channel.
		441	* This parameter can be one of the following values:
		442	* @arg DAC_CHANNEL_1: DAC Channel1 selected
		443	* @arg DAC_CHANNEL_2: DAC Channel2 selected
		444	* @retval HAL status
		445	*/
		446	HAL_StatusTypeDef HAL_DAC_Start(DAC_HandleTypeDef *hdac, uint32_t Channel)
		447	{
		448	/* Check the parameters */
		449	assert_param(IS_DAC_CHANNEL(Channel));
		450
		451	/* Process locked */
		452	__HAL_LOCK(hdac);
		453
		454	/* Change DAC state */
		455	hdac->State = HAL_DAC_STATE_BUSY;
		456
		457	/* Enable the Peripheral */
		458	__HAL_DAC_ENABLE(hdac, Channel);
		459
		460	if (Channel == DAC_CHANNEL_1)
		461	{
		462	/* Check if software trigger enabled */
		463	if ((hdac->Instance->CR & (DAC_CR_TEN1 \| DAC_CR_TSEL1)) == DAC_TRIGGER_SOFTWARE)
		464	{
		465	/* Enable the selected DAC software conversion */
		466	SET_BIT(hdac->Instance->SWTRIGR, DAC_SWTRIGR_SWTRIG1);
		467	}
		468	}
61	mjames	469
56	mjames	470	else
		471	{
		472	/* Check if software trigger enabled */
61	mjames	473	if ((hdac->Instance->CR & (DAC_CR_TEN2 \| DAC_CR_TSEL2)) == (DAC_TRIGGER_SOFTWARE << (Channel & 0x10UL)))
56	mjames	474	{
		475	/* Enable the selected DAC software conversion*/
		476	SET_BIT(hdac->Instance->SWTRIGR, DAC_SWTRIGR_SWTRIG2);
		477	}
		478	}
		479
61	mjames	480
56	mjames	481	/* Change DAC state */
		482	hdac->State = HAL_DAC_STATE_READY;
		483
		484	/* Process unlocked */
		485	__HAL_UNLOCK(hdac);
		486
		487	/* Return function status */
		488	return HAL_OK;
		489	}
		490
		491	/**
		492	* @brief Disables DAC and stop conversion of channel.
		493	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		494	* the configuration information for the specified DAC.
		495	* @param Channel The selected DAC channel.
		496	* This parameter can be one of the following values:
		497	* @arg DAC_CHANNEL_1: DAC Channel1 selected
		498	* @arg DAC_CHANNEL_2: DAC Channel2 selected
		499	* @retval HAL status
		500	*/
		501	HAL_StatusTypeDef HAL_DAC_Stop(DAC_HandleTypeDef *hdac, uint32_t Channel)
		502	{
		503	/* Check the parameters */
		504	assert_param(IS_DAC_CHANNEL(Channel));
		505
		506	/* Disable the Peripheral */
		507	__HAL_DAC_DISABLE(hdac, Channel);
		508
		509	/* Change DAC state */
		510	hdac->State = HAL_DAC_STATE_READY;
		511
		512	/* Return function status */
		513	return HAL_OK;
		514	}
		515
		516	/**
		517	* @brief Enables DAC and starts conversion of channel.
		518	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		519	* the configuration information for the specified DAC.
		520	* @param Channel The selected DAC channel.
		521	* This parameter can be one of the following values:
		522	* @arg DAC_CHANNEL_1: DAC Channel1 selected
		523	* @arg DAC_CHANNEL_2: DAC Channel2 selected
61	mjames	524	* @param pData The source Buffer address.
56	mjames	525	* @param Length The length of data to be transferred from memory to DAC peripheral
		526	* @param Alignment Specifies the data alignment for DAC channel.
		527	* This parameter can be one of the following values:
		528	* @arg DAC_ALIGN_8B_R: 8bit right data alignment selected
		529	* @arg DAC_ALIGN_12B_L: 12bit left data alignment selected
		530	* @arg DAC_ALIGN_12B_R: 12bit right data alignment selected
		531	* @retval HAL status
		532	*/
		533	HAL_StatusTypeDef HAL_DAC_Start_DMA(DAC_HandleTypeDef hdac, uint32_t Channel, uint32_t pData, uint32_t Length,
		534	uint32_t Alignment)
		535	{
		536	HAL_StatusTypeDef status;
		537	uint32_t tmpreg = 0U;
		538
		539	/* Check the parameters */
		540	assert_param(IS_DAC_CHANNEL(Channel));
		541	assert_param(IS_DAC_ALIGN(Alignment));
		542
		543	/* Process locked */
		544	__HAL_LOCK(hdac);
		545
		546	/* Change DAC state */
		547	hdac->State = HAL_DAC_STATE_BUSY;
		548
		549	if (Channel == DAC_CHANNEL_1)
		550	{
		551	/* Set the DMA transfer complete callback for channel1 */
		552	hdac->DMA_Handle1->XferCpltCallback = DAC_DMAConvCpltCh1;
		553
		554	/* Set the DMA half transfer complete callback for channel1 */
		555	hdac->DMA_Handle1->XferHalfCpltCallback = DAC_DMAHalfConvCpltCh1;
		556
		557	/* Set the DMA error callback for channel1 */
		558	hdac->DMA_Handle1->XferErrorCallback = DAC_DMAErrorCh1;
		559
		560	/* Enable the selected DAC channel1 DMA request */
		561	SET_BIT(hdac->Instance->CR, DAC_CR_DMAEN1);
		562
		563	/* Case of use of channel 1 */
		564	switch (Alignment)
		565	{
		566	case DAC_ALIGN_12B_R:
		567	/* Get DHR12R1 address */
		568	tmpreg = (uint32_t)&hdac->Instance->DHR12R1;
		569	break;
		570	case DAC_ALIGN_12B_L:
		571	/* Get DHR12L1 address */
		572	tmpreg = (uint32_t)&hdac->Instance->DHR12L1;
		573	break;
		574	case DAC_ALIGN_8B_R:
		575	/* Get DHR8R1 address */
		576	tmpreg = (uint32_t)&hdac->Instance->DHR8R1;
		577	break;
		578	default:
		579	break;
		580	}
		581	}
61	mjames	582
56	mjames	583	else
		584	{
		585	/* Set the DMA transfer complete callback for channel2 */
		586	hdac->DMA_Handle2->XferCpltCallback = DAC_DMAConvCpltCh2;
		587
		588	/* Set the DMA half transfer complete callback for channel2 */
		589	hdac->DMA_Handle2->XferHalfCpltCallback = DAC_DMAHalfConvCpltCh2;
		590
		591	/* Set the DMA error callback for channel2 */
		592	hdac->DMA_Handle2->XferErrorCallback = DAC_DMAErrorCh2;
		593
		594	/* Enable the selected DAC channel2 DMA request */
		595	SET_BIT(hdac->Instance->CR, DAC_CR_DMAEN2);
		596
		597	/* Case of use of channel 2 */
		598	switch (Alignment)
		599	{
		600	case DAC_ALIGN_12B_R:
		601	/* Get DHR12R2 address */
		602	tmpreg = (uint32_t)&hdac->Instance->DHR12R2;
		603	break;
		604	case DAC_ALIGN_12B_L:
		605	/* Get DHR12L2 address */
		606	tmpreg = (uint32_t)&hdac->Instance->DHR12L2;
		607	break;
		608	case DAC_ALIGN_8B_R:
		609	/* Get DHR8R2 address */
		610	tmpreg = (uint32_t)&hdac->Instance->DHR8R2;
		611	break;
		612	default:
		613	break;
		614	}
		615	}
		616
61	mjames	617
56	mjames	618	/* Enable the DMA channel */
		619	if (Channel == DAC_CHANNEL_1)
		620	{
		621	/* Enable the DAC DMA underrun interrupt */
		622	__HAL_DAC_ENABLE_IT(hdac, DAC_IT_DMAUDR1);
		623
		624	/* Enable the DMA channel */
		625	status = HAL_DMA_Start_IT(hdac->DMA_Handle1, (uint32_t)pData, tmpreg, Length);
		626	}
61	mjames	627
56	mjames	628	else
		629	{
		630	/* Enable the DAC DMA underrun interrupt */
		631	__HAL_DAC_ENABLE_IT(hdac, DAC_IT_DMAUDR2);
		632
		633	/* Enable the DMA channel */
		634	status = HAL_DMA_Start_IT(hdac->DMA_Handle2, (uint32_t)pData, tmpreg, Length);
		635	}
		636
61	mjames	637
56	mjames	638	/* Process Unlocked */
		639	__HAL_UNLOCK(hdac);
		640
		641	if (status == HAL_OK)
		642	{
		643	/* Enable the Peripheral */
		644	__HAL_DAC_ENABLE(hdac, Channel);
		645	}
		646	else
		647	{
		648	hdac->ErrorCode \|= HAL_DAC_ERROR_DMA;
		649	}
		650
		651	/* Return function status */
		652	return status;
		653	}
		654
		655	/**
		656	* @brief Disables DAC and stop conversion of channel.
		657	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		658	* the configuration information for the specified DAC.
		659	* @param Channel The selected DAC channel.
		660	* This parameter can be one of the following values:
		661	* @arg DAC_CHANNEL_1: DAC Channel1 selected
		662	* @arg DAC_CHANNEL_2: DAC Channel2 selected
		663	* @retval HAL status
		664	*/
		665	HAL_StatusTypeDef HAL_DAC_Stop_DMA(DAC_HandleTypeDef *hdac, uint32_t Channel)
		666	{
		667	/* Check the parameters */
		668	assert_param(IS_DAC_CHANNEL(Channel));
		669
		670	/* Disable the selected DAC channel DMA request */
		671	hdac->Instance->CR &= ~(DAC_CR_DMAEN1 << (Channel & 0x10UL));
		672
		673	/* Disable the Peripheral */
		674	__HAL_DAC_DISABLE(hdac, Channel);
		675
		676	/* Disable the DMA channel */
		677
		678	/* Channel1 is used */
		679	if (Channel == DAC_CHANNEL_1)
		680	{
		681	/* Disable the DMA channel */
61	mjames	682	(void)HAL_DMA_Abort(hdac->DMA_Handle1);
56	mjames	683
		684	/* Disable the DAC DMA underrun interrupt */
		685	__HAL_DAC_DISABLE_IT(hdac, DAC_IT_DMAUDR1);
		686	}
61	mjames	687
56	mjames	688	else /* Channel2 is used for */
		689	{
		690	/* Disable the DMA channel */
61	mjames	691	(void)HAL_DMA_Abort(hdac->DMA_Handle2);
56	mjames	692
		693	/* Disable the DAC DMA underrun interrupt */
		694	__HAL_DAC_DISABLE_IT(hdac, DAC_IT_DMAUDR2);
		695	}
		696
		697
61	mjames	698	/* Change DAC state */
		699	hdac->State = HAL_DAC_STATE_READY;
		700
56	mjames	701	/* Return function status */
61	mjames	702	return HAL_OK;
56	mjames	703	}
		704
		705	/**
		706	* @brief Handles DAC interrupt request
		707	* This function uses the interruption of DMA
		708	* underrun.
		709	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		710	* the configuration information for the specified DAC.
		711	* @retval None
		712	*/
		713	void HAL_DAC_IRQHandler(DAC_HandleTypeDef *hdac)
		714	{
		715	if (__HAL_DAC_GET_IT_SOURCE(hdac, DAC_IT_DMAUDR1))
		716	{
		717	/* Check underrun flag of DAC channel 1 */
		718	if (__HAL_DAC_GET_FLAG(hdac, DAC_FLAG_DMAUDR1))
		719	{
		720	/* Change DAC state to error state */
		721	hdac->State = HAL_DAC_STATE_ERROR;
		722
61	mjames	723	/* Set DAC error code to channel1 DMA underrun error */
56	mjames	724	SET_BIT(hdac->ErrorCode, HAL_DAC_ERROR_DMAUNDERRUNCH1);
		725
		726	/* Clear the underrun flag */
		727	__HAL_DAC_CLEAR_FLAG(hdac, DAC_FLAG_DMAUDR1);
		728
		729	/* Disable the selected DAC channel1 DMA request */
		730	CLEAR_BIT(hdac->Instance->CR, DAC_CR_DMAEN1);
		731
		732	/* Error callback */
		733	#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
		734	hdac->DMAUnderrunCallbackCh1(hdac);
		735	#else
		736	HAL_DAC_DMAUnderrunCallbackCh1(hdac);
		737	#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
		738	}
		739	}
		740
61	mjames	741
56	mjames	742	if (__HAL_DAC_GET_IT_SOURCE(hdac, DAC_IT_DMAUDR2))
		743	{
		744	/* Check underrun flag of DAC channel 2 */
		745	if (__HAL_DAC_GET_FLAG(hdac, DAC_FLAG_DMAUDR2))
		746	{
		747	/* Change DAC state to error state */
		748	hdac->State = HAL_DAC_STATE_ERROR;
		749
		750	/* Set DAC error code to channel2 DMA underrun error */
		751	SET_BIT(hdac->ErrorCode, HAL_DAC_ERROR_DMAUNDERRUNCH2);
		752
		753	/* Clear the underrun flag */
		754	__HAL_DAC_CLEAR_FLAG(hdac, DAC_FLAG_DMAUDR2);
		755
		756	/* Disable the selected DAC channel2 DMA request */
		757	CLEAR_BIT(hdac->Instance->CR, DAC_CR_DMAEN2);
		758
		759	/* Error callback */
		760	#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
		761	hdac->DMAUnderrunCallbackCh2(hdac);
		762	#else
		763	HAL_DACEx_DMAUnderrunCallbackCh2(hdac);
		764	#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
		765	}
		766	}
61	mjames	767
56	mjames	768	}
		769
		770	/**
		771	* @brief Set the specified data holding register value for DAC channel.
		772	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		773	* the configuration information for the specified DAC.
		774	* @param Channel The selected DAC channel.
		775	* This parameter can be one of the following values:
		776	* @arg DAC_CHANNEL_1: DAC Channel1 selected
		777	* @arg DAC_CHANNEL_2: DAC Channel2 selected
		778	* @param Alignment Specifies the data alignment.
		779	* This parameter can be one of the following values:
		780	* @arg DAC_ALIGN_8B_R: 8bit right data alignment selected
		781	* @arg DAC_ALIGN_12B_L: 12bit left data alignment selected
		782	* @arg DAC_ALIGN_12B_R: 12bit right data alignment selected
		783	* @param Data Data to be loaded in the selected data holding register.
		784	* @retval HAL status
		785	*/
		786	HAL_StatusTypeDef HAL_DAC_SetValue(DAC_HandleTypeDef *hdac, uint32_t Channel, uint32_t Alignment, uint32_t Data)
		787	{
61	mjames	788	__IO uint32_t tmp = 0UL;
56	mjames	789
		790	/* Check the parameters */
		791	assert_param(IS_DAC_CHANNEL(Channel));
		792	assert_param(IS_DAC_ALIGN(Alignment));
		793	assert_param(IS_DAC_DATA(Data));
		794
		795	tmp = (uint32_t)hdac->Instance;
		796	if (Channel == DAC_CHANNEL_1)
		797	{
		798	tmp += DAC_DHR12R1_ALIGNMENT(Alignment);
		799	}
61	mjames	800
56	mjames	801	else
		802	{
		803	tmp += DAC_DHR12R2_ALIGNMENT(Alignment);
		804	}
		805
61	mjames	806
56	mjames	807	/* Set the DAC channel selected data holding register */
		808	(__IO uint32_t ) tmp = Data;
		809
		810	/* Return function status */
		811	return HAL_OK;
		812	}
		813
		814	/**
		815	* @brief Conversion complete callback in non-blocking mode for Channel1
		816	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		817	* the configuration information for the specified DAC.
		818	* @retval None
		819	*/
		820	__weak void HAL_DAC_ConvCpltCallbackCh1(DAC_HandleTypeDef *hdac)
		821	{
		822	/* Prevent unused argument(s) compilation warning */
		823	UNUSED(hdac);
		824
		825	/* NOTE : This function should not be modified, when the callback is needed,
		826	the HAL_DAC_ConvCpltCallbackCh1 could be implemented in the user file
		827	*/
		828	}
		829
		830	/**
		831	* @brief Conversion half DMA transfer callback in non-blocking mode for Channel1
		832	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		833	* the configuration information for the specified DAC.
		834	* @retval None
		835	*/
		836	__weak void HAL_DAC_ConvHalfCpltCallbackCh1(DAC_HandleTypeDef *hdac)
		837	{
		838	/* Prevent unused argument(s) compilation warning */
		839	UNUSED(hdac);
		840
		841	/* NOTE : This function should not be modified, when the callback is needed,
		842	the HAL_DAC_ConvHalfCpltCallbackCh1 could be implemented in the user file
		843	*/
		844	}
		845
		846	/**
		847	* @brief Error DAC callback for Channel1.
		848	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		849	* the configuration information for the specified DAC.
		850	* @retval None
		851	*/
		852	__weak void HAL_DAC_ErrorCallbackCh1(DAC_HandleTypeDef *hdac)
		853	{
		854	/* Prevent unused argument(s) compilation warning */
		855	UNUSED(hdac);
		856
		857	/* NOTE : This function should not be modified, when the callback is needed,
		858	the HAL_DAC_ErrorCallbackCh1 could be implemented in the user file
		859	*/
		860	}
		861
		862	/**
		863	* @brief DMA underrun DAC callback for channel1.
		864	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		865	* the configuration information for the specified DAC.
		866	* @retval None
		867	*/
		868	__weak void HAL_DAC_DMAUnderrunCallbackCh1(DAC_HandleTypeDef *hdac)
		869	{
		870	/* Prevent unused argument(s) compilation warning */
		871	UNUSED(hdac);
		872
		873	/* NOTE : This function should not be modified, when the callback is needed,
		874	the HAL_DAC_DMAUnderrunCallbackCh1 could be implemented in the user file
		875	*/
		876	}
		877
		878	/**
		879	* @}
		880	*/
		881
		882	/** @defgroup DAC_Exported_Functions_Group3 Peripheral Control functions
		883	* @brief Peripheral Control functions
		884	*
		885	@verbatim
		886	==============================================================================
		887	##### Peripheral Control functions #####
		888	==============================================================================
		889	[..] This section provides functions allowing to:
		890	(+) Configure channels.
		891	(+) Set the specified data holding register value for DAC channel.
		892
		893	@endverbatim
		894	* @{
		895	*/
		896
		897	/**
		898	* @brief Returns the last data output value of the selected DAC channel.
		899	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		900	* the configuration information for the specified DAC.
		901	* @param Channel The selected DAC channel.
		902	* This parameter can be one of the following values:
		903	* @arg DAC_CHANNEL_1: DAC Channel1 selected
		904	* @arg DAC_CHANNEL_2: DAC Channel2 selected
		905	* @retval The selected DAC channel data output value.
		906	*/
		907	uint32_t HAL_DAC_GetValue(DAC_HandleTypeDef *hdac, uint32_t Channel)
		908	{
61	mjames	909	uint32_t result;
		910
56	mjames	911	/* Check the parameters */
		912	assert_param(IS_DAC_CHANNEL(Channel));
		913
		914	if (Channel == DAC_CHANNEL_1)
		915	{
61	mjames	916	result = hdac->Instance->DOR1;
56	mjames	917	}
61	mjames	918
56	mjames	919	else
		920	{
61	mjames	921	result = hdac->Instance->DOR2;
56	mjames	922	}
61	mjames	923
		924	/* Returns the DAC channel data output register value */
		925	return result;
56	mjames	926	}
		927
		928	/**
		929	* @brief Configures the selected DAC channel.
		930	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		931	* the configuration information for the specified DAC.
		932	* @param sConfig DAC configuration structure.
		933	* @param Channel The selected DAC channel.
		934	* This parameter can be one of the following values:
		935	* @arg DAC_CHANNEL_1: DAC Channel1 selected
		936	* @arg DAC_CHANNEL_2: DAC Channel2 selected
		937	* @retval HAL status
		938	*/
		939	HAL_StatusTypeDef HAL_DAC_ConfigChannel(DAC_HandleTypeDef hdac, DAC_ChannelConfTypeDef sConfig, uint32_t Channel)
		940	{
		941	uint32_t tmpreg1;
		942	uint32_t tmpreg2;
		943
		944	/* Check the DAC parameters */
		945	assert_param(IS_DAC_TRIGGER(sConfig->DAC_Trigger));
		946	assert_param(IS_DAC_OUTPUT_BUFFER_STATE(sConfig->DAC_OutputBuffer));
		947	assert_param(IS_DAC_CHANNEL(Channel));
		948
		949	/* Process locked */
		950	__HAL_LOCK(hdac);
		951
		952	/* Change DAC state */
		953	hdac->State = HAL_DAC_STATE_BUSY;
		954
		955	/* Get the DAC CR value */
		956	tmpreg1 = hdac->Instance->CR;
		957	/* Clear BOFFx, TENx, TSELx, WAVEx and MAMPx bits */
61	mjames	958	tmpreg1 &= ~(((uint32_t)(DAC_CR_MAMP1 \| DAC_CR_WAVE1 \| DAC_CR_TSEL1 \| DAC_CR_TEN1 \| DAC_CR_BOFF1)) << (Channel & 0x10UL));
56	mjames	959	/* Configure for the selected DAC channel: buffer output, trigger */
		960	/* Set TSELx and TENx bits according to DAC_Trigger value */
61	mjames	961	/* Set BOFFx bit according to DAC_OutputBuffer value */
56	mjames	962	tmpreg2 = (sConfig->DAC_Trigger \| sConfig->DAC_OutputBuffer);
		963	/* Calculate CR register value depending on DAC_Channel */
61	mjames	964	tmpreg1 \|= tmpreg2 << (Channel & 0x10UL);
56	mjames	965	/* Write to DAC CR */
		966	hdac->Instance->CR = tmpreg1;
		967	/* Disable wave generation */
61	mjames	968	CLEAR_BIT(hdac->Instance->CR, (DAC_CR_WAVE1 << (Channel & 0x10UL)));
56	mjames	969
		970	/* Change DAC state */
		971	hdac->State = HAL_DAC_STATE_READY;
		972
		973	/* Process unlocked */
		974	__HAL_UNLOCK(hdac);
		975
		976	/* Return function status */
		977	return HAL_OK;
		978	}
		979
		980	/**
		981	* @}
		982	*/
		983
		984	/** @defgroup DAC_Exported_Functions_Group4 Peripheral State and Errors functions
		985	* @brief Peripheral State and Errors functions
		986	*
		987	@verbatim
		988	==============================================================================
		989	##### Peripheral State and Errors functions #####
		990	==============================================================================
		991	[..]
		992	This subsection provides functions allowing to
		993	(+) Check the DAC state.
		994	(+) Check the DAC Errors.
		995
		996	@endverbatim
		997	* @{
		998	*/
		999
		1000	/**
		1001	* @brief return the DAC handle state
		1002	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		1003	* the configuration information for the specified DAC.
		1004	* @retval HAL state
		1005	*/
		1006	HAL_DAC_StateTypeDef HAL_DAC_GetState(DAC_HandleTypeDef *hdac)
		1007	{
		1008	/* Return DAC handle state */
		1009	return hdac->State;
		1010	}
		1011
		1012
		1013	/**
		1014	* @brief Return the DAC error code
		1015	* @param hdac pointer to a DAC_HandleTypeDef structure that contains
		1016	* the configuration information for the specified DAC.
		1017	* @retval DAC Error Code
		1018	*/
		1019	uint32_t HAL_DAC_GetError(DAC_HandleTypeDef *hdac)
		1020	{
		1021	return hdac->ErrorCode;
		1022	}
		1023
		1024	/**
		1025	* @}
		1026	*/
		1027
		1028	/**
		1029	* @}
		1030	*/
		1031
		1032	/** @addtogroup DAC_Exported_Functions
		1033	* @{
		1034	*/
		1035
		1036	/** @addtogroup DAC_Exported_Functions_Group1
		1037	* @{
		1038	*/
		1039	#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
		1040	/**
		1041	* @brief Register a User DAC Callback
		1042	* To be used instead of the weak (surcharged) predefined callback
		1043	* @param hdac DAC handle
		1044	* @param CallbackID ID of the callback to be registered
		1045	* This parameter can be one of the following values:
		1046	* @arg @ref HAL_DAC_ERROR_INVALID_CALLBACK DAC Error Callback ID
		1047	* @arg @ref HAL_DAC_CH1_COMPLETE_CB_ID DAC CH1 Complete Callback ID
		1048	* @arg @ref HAL_DAC_CH1_HALF_COMPLETE_CB_ID DAC CH1 Half Complete Callback ID
		1049	* @arg @ref HAL_DAC_CH1_ERROR_ID DAC CH1 Error Callback ID
		1050	* @arg @ref HAL_DAC_CH1_UNDERRUN_CB_ID DAC CH1 UnderRun Callback ID
		1051	* @arg @ref HAL_DAC_CH2_COMPLETE_CB_ID DAC CH2 Complete Callback ID
		1052	* @arg @ref HAL_DAC_CH2_HALF_COMPLETE_CB_ID DAC CH2 Half Complete Callback ID
		1053	* @arg @ref HAL_DAC_CH2_ERROR_ID DAC CH2 Error Callback ID
		1054	* @arg @ref HAL_DAC_CH2_UNDERRUN_CB_ID DAC CH2 UnderRun Callback ID
		1055	* @arg @ref HAL_DAC_MSPINIT_CB_ID DAC MSP Init Callback ID
		1056	* @arg @ref HAL_DAC_MSPDEINIT_CB_ID DAC MSP DeInit Callback ID
		1057	*
		1058	* @param pCallback pointer to the Callback function
		1059	* @retval status
		1060	*/
		1061	HAL_StatusTypeDef HAL_DAC_RegisterCallback(DAC_HandleTypeDef *hdac, HAL_DAC_CallbackIDTypeDef CallbackID,
		1062	pDAC_CallbackTypeDef pCallback)
		1063	{
		1064	HAL_StatusTypeDef status = HAL_OK;
		1065
		1066	if (pCallback == NULL)
		1067	{
		1068	/* Update the error code */
		1069	hdac->ErrorCode \|= HAL_DAC_ERROR_INVALID_CALLBACK;
		1070	return HAL_ERROR;
		1071	}
		1072
		1073	/* Process locked */
		1074	__HAL_LOCK(hdac);
		1075
		1076	if (hdac->State == HAL_DAC_STATE_READY)
		1077	{
		1078	switch (CallbackID)
		1079	{
		1080	case HAL_DAC_CH1_COMPLETE_CB_ID :
		1081	hdac->ConvCpltCallbackCh1 = pCallback;
		1082	break;
		1083	case HAL_DAC_CH1_HALF_COMPLETE_CB_ID :
		1084	hdac->ConvHalfCpltCallbackCh1 = pCallback;
		1085	break;
		1086	case HAL_DAC_CH1_ERROR_ID :
		1087	hdac->ErrorCallbackCh1 = pCallback;
		1088	break;
		1089	case HAL_DAC_CH1_UNDERRUN_CB_ID :
		1090	hdac->DMAUnderrunCallbackCh1 = pCallback;
		1091	break;
61	mjames	1092
56	mjames	1093	case HAL_DAC_CH2_COMPLETE_CB_ID :
		1094	hdac->ConvCpltCallbackCh2 = pCallback;
		1095	break;
		1096	case HAL_DAC_CH2_HALF_COMPLETE_CB_ID :
		1097	hdac->ConvHalfCpltCallbackCh2 = pCallback;
		1098	break;
		1099	case HAL_DAC_CH2_ERROR_ID :
		1100	hdac->ErrorCallbackCh2 = pCallback;
		1101	break;
		1102	case HAL_DAC_CH2_UNDERRUN_CB_ID :
		1103	hdac->DMAUnderrunCallbackCh2 = pCallback;
		1104	break;
61	mjames	1105
56	mjames	1106	case HAL_DAC_MSPINIT_CB_ID :
		1107	hdac->MspInitCallback = pCallback;
		1108	break;
		1109	case HAL_DAC_MSPDEINIT_CB_ID :
		1110	hdac->MspDeInitCallback = pCallback;
		1111	break;
		1112	default :
		1113	/* Update the error code */
		1114	hdac->ErrorCode \|= HAL_DAC_ERROR_INVALID_CALLBACK;
		1115	/* update return status */
		1116	status = HAL_ERROR;
		1117	break;
		1118	}
		1119	}
		1120	else if (hdac->State == HAL_DAC_STATE_RESET)
		1121	{
		1122	switch (CallbackID)
		1123	{
		1124	case HAL_DAC_MSPINIT_CB_ID :
		1125	hdac->MspInitCallback = pCallback;
		1126	break;
		1127	case HAL_DAC_MSPDEINIT_CB_ID :
		1128	hdac->MspDeInitCallback = pCallback;
		1129	break;
		1130	default :
		1131	/* Update the error code */
		1132	hdac->ErrorCode \|= HAL_DAC_ERROR_INVALID_CALLBACK;
		1133	/* update return status */
		1134	status = HAL_ERROR;
		1135	break;
		1136	}
		1137	}
		1138	else
		1139	{
		1140	/* Update the error code */
		1141	hdac->ErrorCode \|= HAL_DAC_ERROR_INVALID_CALLBACK;
		1142	/* update return status */
		1143	status = HAL_ERROR;
		1144	}
		1145
		1146	/* Release Lock */
		1147	__HAL_UNLOCK(hdac);
		1148	return status;
		1149	}
		1150
		1151	/**
		1152	* @brief Unregister a User DAC Callback
		1153	* DAC Callback is redirected to the weak (surcharged) predefined callback
		1154	* @param hdac DAC handle
		1155	* @param CallbackID ID of the callback to be unregistered
		1156	* This parameter can be one of the following values:
61	mjames	1157	* @arg @ref HAL_DAC_CH1_COMPLETE_CB_ID DAC CH1 transfer Complete Callback ID
56	mjames	1158	* @arg @ref HAL_DAC_CH1_HALF_COMPLETE_CB_ID DAC CH1 Half Complete Callback ID
		1159	* @arg @ref HAL_DAC_CH1_ERROR_ID DAC CH1 Error Callback ID
		1160	* @arg @ref HAL_DAC_CH1_UNDERRUN_CB_ID DAC CH1 UnderRun Callback ID
		1161	* @arg @ref HAL_DAC_CH2_COMPLETE_CB_ID DAC CH2 Complete Callback ID
		1162	* @arg @ref HAL_DAC_CH2_HALF_COMPLETE_CB_ID DAC CH2 Half Complete Callback ID
		1163	* @arg @ref HAL_DAC_CH2_ERROR_ID DAC CH2 Error Callback ID
		1164	* @arg @ref HAL_DAC_CH2_UNDERRUN_CB_ID DAC CH2 UnderRun Callback ID
		1165	* @arg @ref HAL_DAC_MSPINIT_CB_ID DAC MSP Init Callback ID
		1166	* @arg @ref HAL_DAC_MSPDEINIT_CB_ID DAC MSP DeInit Callback ID
		1167	* @arg @ref HAL_DAC_ALL_CB_ID DAC All callbacks
		1168	* @retval status
		1169	*/
		1170	HAL_StatusTypeDef HAL_DAC_UnRegisterCallback(DAC_HandleTypeDef *hdac, HAL_DAC_CallbackIDTypeDef CallbackID)
		1171	{
		1172	HAL_StatusTypeDef status = HAL_OK;
		1173
		1174	/* Process locked */
		1175	__HAL_LOCK(hdac);
		1176
		1177	if (hdac->State == HAL_DAC_STATE_READY)
		1178	{
		1179	switch (CallbackID)
		1180	{
		1181	case HAL_DAC_CH1_COMPLETE_CB_ID :
		1182	hdac->ConvCpltCallbackCh1 = HAL_DAC_ConvCpltCallbackCh1;
		1183	break;
		1184	case HAL_DAC_CH1_HALF_COMPLETE_CB_ID :
		1185	hdac->ConvHalfCpltCallbackCh1 = HAL_DAC_ConvHalfCpltCallbackCh1;
		1186	break;
		1187	case HAL_DAC_CH1_ERROR_ID :
		1188	hdac->ErrorCallbackCh1 = HAL_DAC_ErrorCallbackCh1;
		1189	break;
		1190	case HAL_DAC_CH1_UNDERRUN_CB_ID :
		1191	hdac->DMAUnderrunCallbackCh1 = HAL_DAC_DMAUnderrunCallbackCh1;
		1192	break;
61	mjames	1193
56	mjames	1194	case HAL_DAC_CH2_COMPLETE_CB_ID :
		1195	hdac->ConvCpltCallbackCh2 = HAL_DACEx_ConvCpltCallbackCh2;
		1196	break;
		1197	case HAL_DAC_CH2_HALF_COMPLETE_CB_ID :
		1198	hdac->ConvHalfCpltCallbackCh2 = HAL_DACEx_ConvHalfCpltCallbackCh2;
		1199	break;
		1200	case HAL_DAC_CH2_ERROR_ID :
		1201	hdac->ErrorCallbackCh2 = HAL_DACEx_ErrorCallbackCh2;
		1202	break;
		1203	case HAL_DAC_CH2_UNDERRUN_CB_ID :
		1204	hdac->DMAUnderrunCallbackCh2 = HAL_DACEx_DMAUnderrunCallbackCh2;
		1205	break;
61	mjames	1206
56	mjames	1207	case HAL_DAC_MSPINIT_CB_ID :
		1208	hdac->MspInitCallback = HAL_DAC_MspInit;
		1209	break;
		1210	case HAL_DAC_MSPDEINIT_CB_ID :
		1211	hdac->MspDeInitCallback = HAL_DAC_MspDeInit;
		1212	break;
		1213	case HAL_DAC_ALL_CB_ID :
		1214	hdac->ConvCpltCallbackCh1 = HAL_DAC_ConvCpltCallbackCh1;
		1215	hdac->ConvHalfCpltCallbackCh1 = HAL_DAC_ConvHalfCpltCallbackCh1;
		1216	hdac->ErrorCallbackCh1 = HAL_DAC_ErrorCallbackCh1;
		1217	hdac->DMAUnderrunCallbackCh1 = HAL_DAC_DMAUnderrunCallbackCh1;
61	mjames	1218
56	mjames	1219	hdac->ConvCpltCallbackCh2 = HAL_DACEx_ConvCpltCallbackCh2;
		1220	hdac->ConvHalfCpltCallbackCh2 = HAL_DACEx_ConvHalfCpltCallbackCh2;
		1221	hdac->ErrorCallbackCh2 = HAL_DACEx_ErrorCallbackCh2;
		1222	hdac->DMAUnderrunCallbackCh2 = HAL_DACEx_DMAUnderrunCallbackCh2;
61	mjames	1223
56	mjames	1224	hdac->MspInitCallback = HAL_DAC_MspInit;
		1225	hdac->MspDeInitCallback = HAL_DAC_MspDeInit;
		1226	break;
		1227	default :
		1228	/* Update the error code */
		1229	hdac->ErrorCode \|= HAL_DAC_ERROR_INVALID_CALLBACK;
		1230	/* update return status */
		1231	status = HAL_ERROR;
		1232	break;
		1233	}
		1234	}
		1235	else if (hdac->State == HAL_DAC_STATE_RESET)
		1236	{
		1237	switch (CallbackID)
		1238	{
		1239	case HAL_DAC_MSPINIT_CB_ID :
		1240	hdac->MspInitCallback = HAL_DAC_MspInit;
		1241	break;
		1242	case HAL_DAC_MSPDEINIT_CB_ID :
		1243	hdac->MspDeInitCallback = HAL_DAC_MspDeInit;
		1244	break;
		1245	default :
		1246	/* Update the error code */
		1247	hdac->ErrorCode \|= HAL_DAC_ERROR_INVALID_CALLBACK;
		1248	/* update return status */
		1249	status = HAL_ERROR;
		1250	break;
		1251	}
		1252	}
		1253	else
		1254	{
		1255	/* Update the error code */
		1256	hdac->ErrorCode \|= HAL_DAC_ERROR_INVALID_CALLBACK;
		1257	/* update return status */
		1258	status = HAL_ERROR;
		1259	}
		1260
		1261	/* Release Lock */
		1262	__HAL_UNLOCK(hdac);
		1263	return status;
		1264	}
		1265	#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
		1266
		1267	/**
		1268	* @}
		1269	*/
		1270
		1271	/**
		1272	* @}
		1273	*/
		1274
		1275	/** @addtogroup DAC_Private_Functions
		1276	* @{
		1277	*/
		1278
		1279	/**
		1280	* @brief DMA conversion complete callback.
		1281	* @param hdma pointer to a DMA_HandleTypeDef structure that contains
		1282	* the configuration information for the specified DMA module.
		1283	* @retval None
		1284	*/
		1285	void DAC_DMAConvCpltCh1(DMA_HandleTypeDef *hdma)
		1286	{
		1287	DAC_HandleTypeDef hdac = (DAC_HandleTypeDef )((DMA_HandleTypeDef *)hdma)->Parent;
		1288
		1289	#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
		1290	hdac->ConvCpltCallbackCh1(hdac);
		1291	#else
		1292	HAL_DAC_ConvCpltCallbackCh1(hdac);
		1293	#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
		1294
		1295	hdac->State = HAL_DAC_STATE_READY;
		1296	}
		1297
		1298	/**
		1299	* @brief DMA half transfer complete callback.
		1300	* @param hdma pointer to a DMA_HandleTypeDef structure that contains
		1301	* the configuration information for the specified DMA module.
		1302	* @retval None
		1303	*/
		1304	void DAC_DMAHalfConvCpltCh1(DMA_HandleTypeDef *hdma)
		1305	{
		1306	DAC_HandleTypeDef hdac = (DAC_HandleTypeDef )((DMA_HandleTypeDef *)hdma)->Parent;
		1307	/* Conversion complete callback */
		1308	#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
		1309	hdac->ConvHalfCpltCallbackCh1(hdac);
		1310	#else
		1311	HAL_DAC_ConvHalfCpltCallbackCh1(hdac);
		1312	#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
		1313	}
		1314
		1315	/**
		1316	* @brief DMA error callback
		1317	* @param hdma pointer to a DMA_HandleTypeDef structure that contains
		1318	* the configuration information for the specified DMA module.
		1319	* @retval None
		1320	*/
		1321	void DAC_DMAErrorCh1(DMA_HandleTypeDef *hdma)
		1322	{
		1323	DAC_HandleTypeDef hdac = (DAC_HandleTypeDef )((DMA_HandleTypeDef *)hdma)->Parent;
		1324
		1325	/* Set DAC error code to DMA error */
		1326	hdac->ErrorCode \|= HAL_DAC_ERROR_DMA;
		1327
		1328	#if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
		1329	hdac->ErrorCallbackCh1(hdac);
		1330	#else
		1331	HAL_DAC_ErrorCallbackCh1(hdac);
		1332	#endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
		1333
		1334	hdac->State = HAL_DAC_STATE_READY;
		1335	}
		1336
		1337	/**
		1338	* @}
		1339	*/
		1340
		1341	/**
		1342	* @}
		1343	*/
		1344
		1345	#endif /* DAC1 */
		1346
		1347	#endif /* HAL_DAC_MODULE_ENABLED */
		1348
		1349	/**
		1350	* @}
		1351	*/
		1352
		1353	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

Subversion Repositories DashDisplay

(root)/branches/Dashboard_L152_210623/Drivers/STM32L1xx_HAL_Driver/Src/stm32l1xx_hal_dac.c – Rev 61