STM32L4xx_HAL_Driver  1.14.0
Initialization and de-initialization functions

Initialization and Configuration functions. More...

Functions

HAL_StatusTypeDef HAL_DAC_Init (DAC_HandleTypeDef *hdac)
 Initialize the DAC peripheral according to the specified parameters in the DAC_InitStruct and initialize the associated handle. More...
 
HAL_StatusTypeDef HAL_DAC_DeInit (DAC_HandleTypeDef *hdac)
 Deinitialize the DAC peripheral registers to their default reset values. More...
 
void HAL_DAC_MspInit (DAC_HandleTypeDef *hdac)
 Initialize the DAC MSP. More...
 
void HAL_DAC_MspDeInit (DAC_HandleTypeDef *hdac)
 DeInitialize the DAC MSP. More...
 
HAL_StatusTypeDef HAL_DAC_RegisterCallback (DAC_HandleTypeDef *hdac, HAL_DAC_CallbackIDTypeDef CallbackID, pDAC_CallbackTypeDef pCallback)
 Register a User DAC Callback To be used instead of the weak (surcharged) predefined callback. More...
 
HAL_StatusTypeDef HAL_DAC_UnRegisterCallback (DAC_HandleTypeDef *hdac, HAL_DAC_CallbackIDTypeDef CallbackID)
 Unregister a User DAC Callback DAC Callback is redirected to the weak (surcharged) predefined callback. More...
 

Detailed Description

Initialization and Configuration functions.

  ==============================================================================
              ##### Initialization and de-initialization functions #####
  ==============================================================================
    [..]  This section provides functions allowing to:
      (+) Initialize and configure the DAC.
      (+) De-initialize the DAC.

Function Documentation

◆ HAL_DAC_DeInit()

HAL_StatusTypeDef HAL_DAC_DeInit ( DAC_HandleTypeDef hdac)

Deinitialize the DAC peripheral registers to their default reset values.

Parameters
hdacpointer to a DAC_HandleTypeDef structure that contains the configuration information for the specified DAC.
Return values
HALstatus

Definition at line 438 of file stm32l4xx_hal_dac.c.

439 {
440  /* Check DAC handle */
441  if (hdac == NULL)
442  {
443  return HAL_ERROR;
444  }
445 
446  /* Check the parameters */
447  assert_param(IS_DAC_ALL_INSTANCE(hdac->Instance));
448 
449  /* Change DAC state */
450  hdac->State = HAL_DAC_STATE_BUSY;
451 
452 #if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
453  if (hdac->MspDeInitCallback == NULL)
454  {
455  hdac->MspDeInitCallback = HAL_DAC_MspDeInit;
456  }
457  /* DeInit the low level hardware */
458  hdac->MspDeInitCallback(hdac);
459 #else
460  /* DeInit the low level hardware */
461  HAL_DAC_MspDeInit(hdac);
462 #endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
463 
464  /* Set DAC error code to none */
465  hdac->ErrorCode = HAL_DAC_ERROR_NONE;
466 
467  /* Change DAC state */
468  hdac->State = HAL_DAC_STATE_RESET;
469 
470  /* Release Lock */
471  __HAL_UNLOCK(hdac);
472 
473  /* Return function status */
474  return HAL_OK;
475 }
__HAL_UNLOCK(hrtc)
return HAL_OK
void HAL_DAC_MspDeInit(DAC_HandleTypeDef *hdac)
DeInitialize the DAC MSP.
assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock))

◆ HAL_DAC_Init()

HAL_StatusTypeDef HAL_DAC_Init ( DAC_HandleTypeDef hdac)

Initialize the DAC peripheral according to the specified parameters in the DAC_InitStruct and initialize the associated handle.

Parameters
hdacpointer to a DAC_HandleTypeDef structure that contains the configuration information for the specified DAC.
Return values
HALstatus

Definition at line 377 of file stm32l4xx_hal_dac.c.

378 {
379  /* Check DAC handle */
380  if (hdac == NULL)
381  {
382  return HAL_ERROR;
383  }
384  /* Check the parameters */
385  assert_param(IS_DAC_ALL_INSTANCE(hdac->Instance));
386 
387  if (hdac->State == HAL_DAC_STATE_RESET)
388  {
389 #if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
390  /* Init the DAC Callback settings */
391  hdac->ConvCpltCallbackCh1 = HAL_DAC_ConvCpltCallbackCh1;
392  hdac->ConvHalfCpltCallbackCh1 = HAL_DAC_ConvHalfCpltCallbackCh1;
393  hdac->ErrorCallbackCh1 = HAL_DAC_ErrorCallbackCh1;
394  hdac->DMAUnderrunCallbackCh1 = HAL_DAC_DMAUnderrunCallbackCh1;
395 
396  hdac->ConvCpltCallbackCh2 = HAL_DACEx_ConvCpltCallbackCh2;
397  hdac->ConvHalfCpltCallbackCh2 = HAL_DACEx_ConvHalfCpltCallbackCh2;
398  hdac->ErrorCallbackCh2 = HAL_DACEx_ErrorCallbackCh2;
399  hdac->DMAUnderrunCallbackCh2 = HAL_DACEx_DMAUnderrunCallbackCh2;
400 
401  if (hdac->MspInitCallback == NULL)
402  {
403  hdac->MspInitCallback = HAL_DAC_MspInit;
404  }
405 #endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
406 
407  /* Allocate lock resource and initialize it */
408  hdac->Lock = HAL_UNLOCKED;
409 
410 #if (USE_HAL_DAC_REGISTER_CALLBACKS == 1)
411  /* Init the low level hardware */
412  hdac->MspInitCallback(hdac);
413 #else
414  /* Init the low level hardware */
415  HAL_DAC_MspInit(hdac);
416 #endif /* USE_HAL_DAC_REGISTER_CALLBACKS */
417  }
418 
419  /* Initialize the DAC state*/
420  hdac->State = HAL_DAC_STATE_BUSY;
421 
422  /* Set DAC error code to none */
423  hdac->ErrorCode = HAL_DAC_ERROR_NONE;
424 
425  /* Initialize the DAC state*/
426  hdac->State = HAL_DAC_STATE_READY;
427 
428  /* Return function status */
429  return HAL_OK;
430 }
void HAL_DACEx_ConvCpltCallbackCh2(DAC_HandleTypeDef *hdac)
Conversion complete callback in non-blocking mode for Channel2.
void HAL_DACEx_ConvHalfCpltCallbackCh2(DAC_HandleTypeDef *hdac)
Conversion half DMA transfer callback in non-blocking mode for Channel2.
void HAL_DAC_ConvHalfCpltCallbackCh1(DAC_HandleTypeDef *hdac)
Conversion half DMA transfer callback in non-blocking mode for Channel1.
void HAL_DAC_DMAUnderrunCallbackCh1(DAC_HandleTypeDef *hdac)
DMA underrun DAC callback for channel1.
return HAL_OK
void HAL_DAC_ErrorCallbackCh1(DAC_HandleTypeDef *hdac)
Error DAC callback for Channel1.
void HAL_DAC_ConvCpltCallbackCh1(DAC_HandleTypeDef *hdac)
Conversion complete callback in non-blocking mode for Channel1.
void HAL_DACEx_DMAUnderrunCallbackCh2(DAC_HandleTypeDef *hdac)
DMA underrun DAC callback for Channel2.
void HAL_DAC_MspInit(DAC_HandleTypeDef *hdac)
Initialize the DAC MSP.
assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock))
void HAL_DACEx_ErrorCallbackCh2(DAC_HandleTypeDef *hdac)
Error DAC callback for Channel2.

◆ HAL_DAC_MspDeInit()

__weak void HAL_DAC_MspDeInit ( DAC_HandleTypeDef hdac)

DeInitialize the DAC MSP.

Parameters
hdacpointer to a DAC_HandleTypeDef structure that contains the configuration information for the specified DAC.
Return values
None

Definition at line 499 of file stm32l4xx_hal_dac.c.

500 {
501  /* Prevent unused argument(s) compilation warning */
502  UNUSED(hdac);
503 
504  /* NOTE : This function should not be modified, when the callback is needed,
505  the HAL_DAC_MspDeInit could be implemented in the user file
506  */
507 }

◆ HAL_DAC_MspInit()

__weak void HAL_DAC_MspInit ( DAC_HandleTypeDef hdac)

Initialize the DAC MSP.

Parameters
hdacpointer to a DAC_HandleTypeDef structure that contains the configuration information for the specified DAC.
Return values
None

Definition at line 483 of file stm32l4xx_hal_dac.c.

484 {
485  /* Prevent unused argument(s) compilation warning */
486  UNUSED(hdac);
487 
488  /* NOTE : This function should not be modified, when the callback is needed,
489  the HAL_DAC_MspInit could be implemented in the user file
490  */
491 }

◆ HAL_DAC_RegisterCallback()

HAL_StatusTypeDef HAL_DAC_RegisterCallback ( DAC_HandleTypeDef hdac,
HAL_DAC_CallbackIDTypeDef  CallbackID,
pDAC_CallbackTypeDef  pCallback 
)

Register a User DAC Callback To be used instead of the weak (surcharged) predefined callback.

Parameters
hdacDAC handle
CallbackIDID of the callback to be registered This parameter can be one of the following values:
pCallbackpointer to the Callback function
Return values
status

Definition at line 1457 of file stm32l4xx_hal_dac.c.

1459 {
1460  HAL_StatusTypeDef status = HAL_OK;
1461 
1462  if (pCallback == NULL)
1463  {
1464  /* Update the error code */
1465  hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
1466  return HAL_ERROR;
1467  }
1468 
1469  /* Process locked */
1470  __HAL_LOCK(hdac);
1471 
1472  if (hdac->State == HAL_DAC_STATE_READY)
1473  {
1474  switch (CallbackID)
1475  {
1477  hdac->ConvCpltCallbackCh1 = pCallback;
1478  break;
1480  hdac->ConvHalfCpltCallbackCh1 = pCallback;
1481  break;
1482  case HAL_DAC_CH1_ERROR_ID :
1483  hdac->ErrorCallbackCh1 = pCallback;
1484  break;
1486  hdac->DMAUnderrunCallbackCh1 = pCallback;
1487  break;
1489  hdac->ConvCpltCallbackCh2 = pCallback;
1490  break;
1492  hdac->ConvHalfCpltCallbackCh2 = pCallback;
1493  break;
1494  case HAL_DAC_CH2_ERROR_ID :
1495  hdac->ErrorCallbackCh2 = pCallback;
1496  break;
1498  hdac->DMAUnderrunCallbackCh2 = pCallback;
1499  break;
1500  case HAL_DAC_MSPINIT_CB_ID :
1501  hdac->MspInitCallback = pCallback;
1502  break;
1504  hdac->MspDeInitCallback = pCallback;
1505  break;
1506  default :
1507  /* Update the error code */
1508  hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
1509  /* update return status */
1510  status = HAL_ERROR;
1511  break;
1512  }
1513  }
1514  else if (hdac->State == HAL_DAC_STATE_RESET)
1515  {
1516  switch (CallbackID)
1517  {
1518  case HAL_DAC_MSPINIT_CB_ID :
1519  hdac->MspInitCallback = pCallback;
1520  break;
1522  hdac->MspDeInitCallback = pCallback;
1523  break;
1524  default :
1525  /* Update the error code */
1526  hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
1527  /* update return status */
1528  status = HAL_ERROR;
1529  break;
1530  }
1531  }
1532  else
1533  {
1534  /* Update the error code */
1535  hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
1536  /* update return status */
1537  status = HAL_ERROR;
1538  }
1539 
1540  /* Release Lock */
1541  __HAL_UNLOCK(hdac);
1542  return status;
1543 }
__HAL_UNLOCK(hrtc)
__HAL_LOCK(hrtc)
return HAL_OK

◆ HAL_DAC_UnRegisterCallback()

HAL_StatusTypeDef HAL_DAC_UnRegisterCallback ( DAC_HandleTypeDef hdac,
HAL_DAC_CallbackIDTypeDef  CallbackID 
)

Unregister a User DAC Callback DAC Callback is redirected to the weak (surcharged) predefined callback.

Parameters
hdacDAC handle
CallbackIDID of the callback to be unregistered This parameter can be one of the following values:
Return values
status

Definition at line 1564 of file stm32l4xx_hal_dac.c.

1565 {
1566  HAL_StatusTypeDef status = HAL_OK;
1567 
1568  /* Process locked */
1569  __HAL_LOCK(hdac);
1570 
1571  if (hdac->State == HAL_DAC_STATE_READY)
1572  {
1573  switch (CallbackID)
1574  {
1576  hdac->ConvCpltCallbackCh1 = HAL_DAC_ConvCpltCallbackCh1;
1577  break;
1579  hdac->ConvHalfCpltCallbackCh1 = HAL_DAC_ConvHalfCpltCallbackCh1;
1580  break;
1581  case HAL_DAC_CH1_ERROR_ID :
1582  hdac->ErrorCallbackCh1 = HAL_DAC_ErrorCallbackCh1;
1583  break;
1585  hdac->DMAUnderrunCallbackCh1 = HAL_DAC_DMAUnderrunCallbackCh1;
1586  break;
1588  hdac->ConvCpltCallbackCh2 = HAL_DACEx_ConvCpltCallbackCh2;
1589  break;
1591  hdac->ConvHalfCpltCallbackCh2 = HAL_DACEx_ConvHalfCpltCallbackCh2;
1592  break;
1593  case HAL_DAC_CH2_ERROR_ID :
1594  hdac->ErrorCallbackCh2 = HAL_DACEx_ErrorCallbackCh2;
1595  break;
1597  hdac->DMAUnderrunCallbackCh2 = HAL_DACEx_DMAUnderrunCallbackCh2;
1598  break;
1599  case HAL_DAC_MSPINIT_CB_ID :
1600  hdac->MspInitCallback = HAL_DAC_MspInit;
1601  break;
1603  hdac->MspDeInitCallback = HAL_DAC_MspDeInit;
1604  break;
1605  case HAL_DAC_ALL_CB_ID :
1606  hdac->ConvCpltCallbackCh1 = HAL_DAC_ConvCpltCallbackCh1;
1607  hdac->ConvHalfCpltCallbackCh1 = HAL_DAC_ConvHalfCpltCallbackCh1;
1608  hdac->ErrorCallbackCh1 = HAL_DAC_ErrorCallbackCh1;
1609  hdac->DMAUnderrunCallbackCh1 = HAL_DAC_DMAUnderrunCallbackCh1;
1610  hdac->ConvCpltCallbackCh2 = HAL_DACEx_ConvCpltCallbackCh2;
1611  hdac->ConvHalfCpltCallbackCh2 = HAL_DACEx_ConvHalfCpltCallbackCh2;
1612  hdac->ErrorCallbackCh2 = HAL_DACEx_ErrorCallbackCh2;
1613  hdac->DMAUnderrunCallbackCh2 = HAL_DACEx_DMAUnderrunCallbackCh2;
1614  hdac->MspInitCallback = HAL_DAC_MspInit;
1615  hdac->MspDeInitCallback = HAL_DAC_MspDeInit;
1616  break;
1617  default :
1618  /* Update the error code */
1619  hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
1620  /* update return status */
1621  status = HAL_ERROR;
1622  break;
1623  }
1624  }
1625  else if (hdac->State == HAL_DAC_STATE_RESET)
1626  {
1627  switch (CallbackID)
1628  {
1629  case HAL_DAC_MSPINIT_CB_ID :
1630  hdac->MspInitCallback = HAL_DAC_MspInit;
1631  break;
1633  hdac->MspDeInitCallback = HAL_DAC_MspDeInit;
1634  break;
1635  default :
1636  /* Update the error code */
1637  hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
1638  /* update return status */
1639  status = HAL_ERROR;
1640  break;
1641  }
1642  }
1643  else
1644  {
1645  /* Update the error code */
1646  hdac->ErrorCode |= HAL_DAC_ERROR_INVALID_CALLBACK;
1647  /* update return status */
1648  status = HAL_ERROR;
1649  }
1650 
1651  /* Release Lock */
1652  __HAL_UNLOCK(hdac);
1653  return status;
1654 }
void HAL_DACEx_ConvCpltCallbackCh2(DAC_HandleTypeDef *hdac)
Conversion complete callback in non-blocking mode for Channel2.
void HAL_DACEx_ConvHalfCpltCallbackCh2(DAC_HandleTypeDef *hdac)
Conversion half DMA transfer callback in non-blocking mode for Channel2.
__HAL_UNLOCK(hrtc)
void HAL_DAC_ConvHalfCpltCallbackCh1(DAC_HandleTypeDef *hdac)
Conversion half DMA transfer callback in non-blocking mode for Channel1.
__HAL_LOCK(hrtc)
void HAL_DAC_DMAUnderrunCallbackCh1(DAC_HandleTypeDef *hdac)
DMA underrun DAC callback for channel1.
return HAL_OK
void HAL_DAC_ErrorCallbackCh1(DAC_HandleTypeDef *hdac)
Error DAC callback for Channel1.
void HAL_DAC_ConvCpltCallbackCh1(DAC_HandleTypeDef *hdac)
Conversion complete callback in non-blocking mode for Channel1.
void HAL_DAC_MspDeInit(DAC_HandleTypeDef *hdac)
DeInitialize the DAC MSP.
void HAL_DACEx_DMAUnderrunCallbackCh2(DAC_HandleTypeDef *hdac)
DMA underrun DAC callback for Channel2.
void HAL_DAC_MspInit(DAC_HandleTypeDef *hdac)
Initialize the DAC MSP.
void HAL_DACEx_ErrorCallbackCh2(DAC_HandleTypeDef *hdac)
Error DAC callback for Channel2.