LXR 6.1/​bsps/​arm/​stm32h7/​hal/​stm32h7xx_hal_opamp.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:23:08

 /**
   ******************************************************************************
   * @file    stm32h7xx_hal_opamp.c
   * @author  MCD Application Team
   * @brief   OPAMP HAL module driver.
   *          This file provides firmware functions to manage the following
   *          functionalities of the operational amplifier(s) peripheral:
   *           + Initialization and de-initialization functions
   *           + IO operation functions
   *           + Peripheral Control functions
   *           + Peripheral State functions
   *
   ******************************************************************************
   * @attention
   *
   * Copyright (c) 2017 STMicroelectronics.
   * All rights reserved.
   *
   * This software is licensed under terms that can be found in the LICENSE file
   * in the root directory of this software component.
   * If no LICENSE file comes with this software, it is provided AS-IS.
   *
   ******************************************************************************
   @verbatim
 ================================================================================
           ##### OPAMP Peripheral Features #####
 ================================================================================
 
   [..] The device integrates 2 operational amplifiers OPAMP1 & OPAMP2
 
        (#) The OPAMP(s) provides several exclusive running modes.
        (++) Standalone mode
        (++) Programmable Gain Amplifier (PGA) modes
        (++) Follower mode
 
        (#) Each OPAMP(s) can be configured in normal and high speed mode.
 
        (#) The OPAMP(s) provide(s) calibration capabilities.
        (++) Calibration aims at correcting some offset for running mode.
        (++) The OPAMP uses either factory calibration settings OR user defined
            calibration (trimming) settings (i.e. trimming mode).
        (++) The user defined settings can be figured out using self calibration
            handled by HAL_OPAMP_SelfCalibrate, HAL_OPAMPEx_SelfCalibrateAll
        (++) HAL_OPAMP_SelfCalibrate:
        (+++) Runs automatically the calibration in 2 steps.
             (90% of VDDA for NMOS transistors, 10% of VDDA for PMOS transistors).
             (As OPAMP is Rail-to-rail input/output, these 2 steps calibration is
              appropriate and enough in most cases).
        (+++) Runs automatically the calibration.
        (+++) Enables the user trimming mode
        (+++) Updates the init structure with trimming values with fresh calibration
             results.
             The user may store the calibration results for larger
             (ex monitoring the trimming as a function of temperature
             for instance)
        (+++) HAL_OPAMPEx_SelfCalibrateAll
             runs calibration of all OPAMPs in parallel to save search time.
 
        (#) Running mode: Standalone mode
        (++) Gain is set externally (gain depends on external loads).
        (++) Follower mode also possible externally by connecting the inverting input to
            the output.
 
        (#) Running mode: Follower mode
        (++) No Inverting Input is connected.
 
        (#) Running mode: Programmable Gain Amplifier (PGA) mode
            (Resistor feedback output)
        (#) The OPAMP(s) output(s) can be internally connected to resistor feedback
            output.
        (#) OPAMP gain can be selected as :
 
       (##) Gain of x2, x4, x8 or x16 for non inverting mode with:
       (+++) VREF- referenced.
       (+++) Filtering on VINM0, VREF- referenced.
       (+++) VINM0 node for bias voltage and VINP0 for input signal.
       (+++) VINM0 node for bias voltage and VINP0 for input signal, VINM1 node for filtering.
 
       (##) Gain of x-1, x-3, x-7 or x-15 for inverting mode with:
       (+++) VINM0 node for input signal and VINP0 for bias.
       (+++) VINM0 node for input signal and VINP0 for bias voltage, VINM1 node for filtering.
 
        (#) The OPAMPs inverting input can be selected according to the Reference Manual
            "OPAMP functional description" chapter.
 
        (#) The OPAMPs non inverting input can be selected according to the Reference Manual
            "OPAMP functional description" chapter.
 
 
             ##### How to use this driver #####
 ================================================================================
   [..]
 
     *** High speed / normal power mode ***
     ============================================
     [..]  To run in high speed mode:
 
       (#) Configure the OPAMP using HAL_OPAMP_Init() function:
       (++) Select OPAMP_POWERMODE_HIGHSPEED
       (++) Otherwise select OPAMP_POWERMODE_NORMAL
 
     *** Calibration ***
     ============================================
     [..]  To run the OPAMP calibration self calibration:
 
       (#) Start calibration using HAL_OPAMP_SelfCalibrate.
            Store the calibration results.
 
     *** Running mode ***
     ============================================
 
     [..]  To use the OPAMP, perform the following steps:
 
       (#) Fill in the HAL_OPAMP_MspInit() to
       (++) Enable the OPAMP Peripheral clock using macro __HAL_RCC_OPAMP_CLK_ENABLE()
       (++) Configure the OPAMP input AND output in analog mode using
            HAL_GPIO_Init() to map the OPAMP output to the GPIO pin.
 
       (#) Registrate Callbacks
       (++) The compilation define  USE_HAL_OPAMP_REGISTER_CALLBACKS when set to 1
            allows the user to configure dynamically the driver callbacks.
 
       (++) Use Functions HAL_OPAMP_RegisterCallback() to register a user callback,
            it allows to register following callbacks:
       (+++) MspInitCallback         : OPAMP MspInit.
       (+++) MspDeInitCallback       : OPAMP MspDeInit.
            This function takes as parameters the HAL peripheral handle, the Callback ID
            and a pointer to the user callback function.
 
       (++) Use function HAL_OPAMP_UnRegisterCallback() to reset a callback to the default
            weak (overridden) function. It allows to reset following callbacks:
       (+++) MspInitCallback         : OPAMP MspInit.
       (+++) MspDeInitCallback       : OPAMP MspDeInit.
       (+++) All Callbacks
       (#) Configure the OPAMP using HAL_OPAMP_Init() function:
       (++) Select the mode
       (++) Select the inverting input
       (++) Select the non-inverting input
       (++) If PGA mode is enabled, Select if inverting input is connected.
       (++) Select either factory or user defined trimming mode.
       (++) If the user-defined trimming mode is enabled, select PMOS & NMOS trimming values
           (typically values set by HAL_OPAMP_SelfCalibrate function).
 
       (#) Enable the OPAMP using HAL_OPAMP_Start() function.
 
       (#) Disable the OPAMP using HAL_OPAMP_Stop() function.
 
       (#) Lock the OPAMP in running mode using HAL_OPAMP_Lock() function.
           Caution: On STM32H7, HAL OPAMP lock is software lock only (not
           hardware lock as on some other STM32 devices)
 
       (#) If needed, unlock the OPAMP using HAL_OPAMPEx_Unlock() function.
 
     *** Running mode: change of configuration while OPAMP ON  ***
     ============================================
     [..] To Re-configure OPAMP when OPAMP is ON (change on the fly)
       (#) If needed, fill in the HAL_OPAMP_MspInit()
       (++) This is the case for instance if you wish to use new OPAMP I/O
 
       (#) Configure the OPAMP using HAL_OPAMP_Init() function:
       (++) As in configure case, select first the parameters you wish to modify.
 
       (#) Change from high speed mode to normal power mode (& vice versa) requires
           first HAL_OPAMP_DeInit() (force OPAMP OFF) and then HAL_OPAMP_Init().
           In other words, of OPAMP is ON, HAL_OPAMP_Init can NOT change power mode
           alone.
 
   @endverbatim
   ******************************************************************************
     Table 1.  OPAMPs inverting/non-inverting inputs for the STM32H7 devices:
 
     +------------------------------------------------------------------------|
     |                 |         | OPAMP1               | OPAMP2              |
     |-----------------|---------|----------------------|---------------------|
     | Inverting Input | VM_SEL  |   VINM0-> PC5        |    VINM0-> PE8      |
     |                 |         |   VINM1-> PA7        |    VINM1-> PG1      |
     |                 |         |   Internal:          |    Internal:        |
     |                 |         |     ADC1_IN9         |      OPAMP2_OUT     |
     |                 |         |     ADC2_IN9         |     PGA mode        |
     |                 |         |     OPAMP1_OUT       |                     |
     |                 |         |     PGA mode         |                     |
     |-----------------|---------|----------------------|---------------------|
     |  Non Inverting  | VP_SEL  |                      |                     |
     |                 |         |  VP0 -> PB0 (GPIO)   |  VP0 -> PE9 (GPIO)  |
     |                 |         |  Internal:           |  Internal:          |
     |    Input        |         |    DAC1_CH1_int      |   DAC1_CH2_int      |
     |                 |         |    ADC1_IN8          |   DAC2_CH1_int      |
     |                 |         |    ADC2_IN8          |   COMP2_INP         |
     |                 |         |    COMP1_INP         |                     |
     +------------------------------------------------------------------------|
 
 
    [..] Table 2.  OPAMPs outputs for the STM32H7 devices:
 
     +-------------------------------------------------------------------------
     |                 |        | OPAMP1                | OPAMP2              |
     |-----------------|--------|-----------------------|---------------------|
     | Output          |  VOUT  |  PC4                  |  PE7                |
     |                 |        |  & ADC1_IN4|          | & COMP2_INN7 if     |
     |                 |        |    ADC2_IN4           |connected internally |
     |                 |        |   COMP1_INN7 if       |                     |
     |                 |        |  connected internally |                     |
     |-----------------|--------|-----------------------|---------------------|
   */
 
 /* Includes ------------------------------------------------------------------*/
 #include "stm32h7xx_hal.h"
 
 /** @addtogroup STM32H7xx_HAL_Driver
   * @{
   */
 
 /** @defgroup OPAMP OPAMP
   * @ingroup RTEMSBSPsARMSTM32H7
   * @brief OPAMP module driver
   * @{
   */
 
 #ifdef HAL_OPAMP_MODULE_ENABLED
 
 /* Private types -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 /* Private constants ---------------------------------------------------------*/
 /** @addtogroup OPAMP_Private_Constants
   * @{
   */
 
 /* CSR register reset value */
 #define OPAMP_CSR_RESET_VALUE             0x00000000U
 
 /* CSR Init masks */
 
 #define OPAMP_CSR_INIT_MASK_PGA (OPAMP_CSR_OPAHSM | OPAMP_CSR_VMSEL | OPAMP_CSR_PGGAIN | OPAMP_CSR_PGGAIN  \
                                 | OPAMP_CSR_VPSEL | OPAMP_CSR_USERTRIM)
 
 
 #define OPAMP_CSR_INIT_MASK_FOLLOWER (OPAMP_CSR_OPAHSM | OPAMP_CSR_VMSEL| OPAMP_CSR_VPSEL \
                                     | OPAMP_CSR_USERTRIM)
 
 
 #define OPAMP_CSR_INIT_MASK_STANDALONE (OPAMP_CSR_OPAHSM | OPAMP_CSR_VMSEL | OPAMP_CSR_VPSEL  \
                                        | OPAMP_CSR_VMSEL | OPAMP_CSR_USERTRIM)
 /**
   * @}
   */
 
 /* Private macros ------------------------------------------------------------*/
 /* Private functions ---------------------------------------------------------*/
 /* Exported functions --------------------------------------------------------*/
 
 /** @defgroup OPAMP_Exported_Functions OPAMP Exported Functions
   * @ingroup RTEMSBSPsARMSTM32H7
   * @{
   */
 
 /** @defgroup OPAMP_Exported_Functions_Group1 Initialization and de-initialization functions
   * @ingroup RTEMSBSPsARMSTM32H7
  *  @brief    Initialization and Configuration functions
  *
 @verbatim
   ==============================================================================
               ##### Initialization and de-initialization functions #####
   ==============================================================================
 
 @endverbatim
   * @{
   */
 
 /**
   * @brief  Initialize the OPAMP according to the specified
   *         parameters in the OPAMP_InitTypeDef and initialize the associated handle.
   * @note   If the selected opamp is locked, initialization can't be performed.
   *         To unlock the configuration, perform a system reset.
   * @param  hopamp OPAMP handle
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_OPAMP_Init(OPAMP_HandleTypeDef *hopamp)
 {
   HAL_StatusTypeDef status = HAL_OK;
   uint32_t updateotrlpotr;
 
   /* Check the OPAMP handle allocation and lock status */
   /* Init not allowed if calibration is ongoing */
   if(hopamp == NULL)
   {
     return HAL_ERROR;
   }
   else if(hopamp->State == HAL_OPAMP_STATE_BUSYLOCKED)
   {
     return HAL_ERROR;
   }
   else if(hopamp->State == HAL_OPAMP_STATE_CALIBBUSY)
   {
     return HAL_ERROR;
   }
   else
   {
     /* Check the parameter */
     assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
 
     /* Set OPAMP parameters */
     assert_param(IS_OPAMP_POWERMODE(hopamp->Init.PowerMode));
     assert_param(IS_OPAMP_FUNCTIONAL_NORMALMODE(hopamp->Init.Mode));
     assert_param(IS_OPAMP_NONINVERTING_INPUT(hopamp->Init.NonInvertingInput));
 
 #if (USE_HAL_OPAMP_REGISTER_CALLBACKS == 1)
     if(hopamp->State == HAL_OPAMP_STATE_RESET)
     {
       if(hopamp->MspInitCallback == NULL)
       {
         hopamp->MspInitCallback               = HAL_OPAMP_MspInit;
       }
     }
 #endif /* USE_HAL_OPAMP_REGISTER_CALLBACKS */
     if ((hopamp->Init.Mode) == OPAMP_STANDALONE_MODE)
     {
       assert_param(IS_OPAMP_INVERTING_INPUT_STANDALONE(hopamp->Init.InvertingInput));
     }
 
     if ((hopamp->Init.Mode) == OPAMP_PGA_MODE)
     {
       assert_param(IS_OPAMP_PGA_GAIN(hopamp->Init.PgaGain));
       assert_param(IS_OPAMP_PGACONNECT(hopamp->Init.PgaConnect));
     }
 
 
     assert_param(IS_OPAMP_TRIMMING(hopamp->Init.UserTrimming));
 
     if ((hopamp->Init.UserTrimming) == OPAMP_TRIMMING_USER)
     {
       if (hopamp->Init.PowerMode == OPAMP_POWERMODE_NORMAL)
       {
         assert_param(IS_OPAMP_TRIMMINGVALUE(hopamp->Init.TrimmingValueP));
         assert_param(IS_OPAMP_TRIMMINGVALUE(hopamp->Init.TrimmingValueN));
       }
     else
       {
         assert_param(IS_OPAMP_TRIMMINGVALUE(hopamp->Init.TrimmingValuePHighSpeed));
         assert_param(IS_OPAMP_TRIMMINGVALUE(hopamp->Init.TrimmingValueNHighSpeed));
       }
     }
 
     if(hopamp->State == HAL_OPAMP_STATE_RESET)
     {
       /* Allocate lock resource and initialize it */
       hopamp->Lock = HAL_UNLOCKED;
     }
 
 #if (USE_HAL_OPAMP_REGISTER_CALLBACKS == 1)
     hopamp->MspInitCallback(hopamp);
 #else
     /* Call MSP init function */
     HAL_OPAMP_MspInit(hopamp);
 #endif /* USE_HAL_OPAMP_REGISTER_CALLBACKS */
 
     /* Set operating mode */
     CLEAR_BIT(hopamp->Instance->CSR, OPAMP_CSR_CALON);
     /* In PGA mode InvertingInput is Not Applicable  */
     if (hopamp->Init.Mode == OPAMP_PGA_MODE)
     {
       MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_INIT_MASK_PGA, \
                                         hopamp->Init.PowerMode | \
                                         hopamp->Init.Mode | \
                                         hopamp->Init.PgaGain | \
                                         hopamp->Init.PgaConnect | \
                                         hopamp->Init.NonInvertingInput | \
                                         hopamp->Init.UserTrimming);
     }
 
     if (hopamp->Init.Mode == OPAMP_FOLLOWER_MODE)
     {
   /* In Follower mode InvertingInput is Not Applicable  */
     MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_INIT_MASK_FOLLOWER, \
                                               hopamp->Init.PowerMode | \
                                               hopamp->Init.Mode | \
                                               hopamp->Init.NonInvertingInput | \
                                               hopamp->Init.UserTrimming);
     }
 
     if (hopamp->Init.Mode == OPAMP_STANDALONE_MODE)
     {
       MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_INIT_MASK_STANDALONE, \
                                         hopamp->Init.PowerMode | \
                                         hopamp->Init.Mode | \
                                         hopamp->Init.InvertingInput    | \
                                         hopamp->Init.NonInvertingInput | \
                                         hopamp->Init.UserTrimming);
     }
 
     if (hopamp->Init.UserTrimming == OPAMP_TRIMMING_USER)
     {
       /* Set power mode and associated calibration parameters */
       if (hopamp->Init.PowerMode != OPAMP_POWERMODE_HIGHSPEED)
       {
         /* OPAMP_POWERMODE_NORMAL */
         /* Set calibration mode (factory or user) and values for            */
         /* transistors differential pair high (PMOS) and low (NMOS) for     */
         /* normal mode.                                                     */
         updateotrlpotr = (((hopamp->Init.TrimmingValueP) << (OPAMP_INPUT_NONINVERTING)) \
                          | (hopamp->Init.TrimmingValueN));
         MODIFY_REG(hopamp->Instance->OTR, OPAMP_OTR_TRIMOFFSETN | OPAMP_OTR_TRIMOFFSETP, updateotrlpotr);
       }
       else
       {
         /* OPAMP_POWERMODE_HIGHSPEED*/
         /* transistors differential pair high (PMOS) and low (NMOS) for     */
         /* high speed mode.                                                     */
         updateotrlpotr = (((hopamp->Init.TrimmingValuePHighSpeed) << (OPAMP_INPUT_NONINVERTING)) \
                          | (hopamp->Init.TrimmingValueNHighSpeed));
         MODIFY_REG(hopamp->Instance->HSOTR, OPAMP_OTR_TRIMOFFSETN | OPAMP_OTR_TRIMOFFSETP, updateotrlpotr);
       }
     }
 
     /* Update the OPAMP state*/
     if (hopamp->State == HAL_OPAMP_STATE_RESET)
     {
       /* From RESET state to READY State */
       hopamp->State = HAL_OPAMP_STATE_READY;
     }
     /* else: remain in READY or BUSY state (no update) */
     return status;
   }
 }
 
 /**
   * @brief  DeInitialize the OPAMP peripheral
   * @note   Deinitialization can be performed if the OPAMP configuration is locked.
   *         (the lock is SW in H7)
   * @param  hopamp OPAMP handle
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_OPAMP_DeInit(OPAMP_HandleTypeDef *hopamp)
 {
   HAL_StatusTypeDef status = HAL_OK;
 
   /* Check the OPAMP handle allocation */
   /* DeInit not allowed if calibration is on going */
   if(hopamp == NULL)
   {
     status = HAL_ERROR;
   }
   else if(hopamp->State == HAL_OPAMP_STATE_CALIBBUSY)
   {
     status = HAL_ERROR;
   }
   else
   {
     /* Check the parameter */
     assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
 
     /* Set OPAMP_CSR register to reset value */
     WRITE_REG(hopamp->Instance->CSR, OPAMP_CSR_RESET_VALUE);
 
     /* DeInit the low level hardware */
 #if (USE_HAL_OPAMP_REGISTER_CALLBACKS == 1)
     if(hopamp->MspDeInitCallback == NULL)
     {
       hopamp->MspDeInitCallback = HAL_OPAMP_MspDeInit;
     }
     /* DeInit the low level hardware */
     hopamp->MspDeInitCallback(hopamp);
 #else
     HAL_OPAMP_MspDeInit(hopamp);
 #endif /* USE_HAL_OPAMP_REGISTER_CALLBACKS */
 
     /* Update the OPAMP state*/
     hopamp->State = HAL_OPAMP_STATE_RESET;
     /* Process unlocked */
     __HAL_UNLOCK(hopamp);
 
   }
 
   return status;
 }
 
 
 /**
   * @brief  Initialize the OPAMP MSP.
   * @param  hopamp OPAMP handle
   * @retval None
   */
 __weak void HAL_OPAMP_MspInit(OPAMP_HandleTypeDef *hopamp)
 {
   /* Prevent unused argument(s) compilation warning */
   UNUSED(hopamp);
 
   /* NOTE : This function should not be modified, when the callback is needed,
             the function "HAL_OPAMP_MspInit()" must be implemented in the user file.
    */
 }
 
 /**
   * @brief  DeInitialize OPAMP MSP.
   * @param  hopamp OPAMP handle
   * @retval None
   */
 __weak void HAL_OPAMP_MspDeInit(OPAMP_HandleTypeDef *hopamp)
 {
   /* Prevent unused argument(s) compilation warning */
   UNUSED(hopamp);
   /* NOTE : This function should not be modified, when the callback is needed,
             the function "HAL_OPAMP_MspDeInit()" must be implemented in the user file.
    */
 }
 
 /**
   * @}
   */
 
 
 /** @defgroup OPAMP_Exported_Functions_Group2 IO operation functions
   * @ingroup RTEMSBSPsARMSTM32H7
  *  @brief   IO operation functions
  *
 @verbatim
  ===============================================================================
                         ##### IO operation functions #####
  ===============================================================================
     [..]
     This subsection provides a set of functions allowing to manage the OPAMP
     start, stop and calibration actions.
 
 @endverbatim
   * @{
   */
 
 /**
   * @brief  Start the OPAMP.
   * @param  hopamp OPAMP handle
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_OPAMP_Start(OPAMP_HandleTypeDef *hopamp)
 {
   HAL_StatusTypeDef status = HAL_OK;
 
   /* Check the OPAMP handle allocation */
   /* Check if OPAMP locked */
   if(hopamp == NULL)
   {
     status = HAL_ERROR;
   }
   else if(hopamp->State == HAL_OPAMP_STATE_BUSYLOCKED)
   {
     status = HAL_ERROR;
   }
   else
   {
     /* Check the parameter */
     assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
 
     if(hopamp->State == HAL_OPAMP_STATE_READY)
     {
       /* Enable the selected opamp */
       SET_BIT (hopamp->Instance->CSR, OPAMP_CSR_OPAMPxEN);
 
       /* Update the OPAMP state*/
       /* From HAL_OPAMP_STATE_READY to HAL_OPAMP_STATE_BUSY */
       hopamp->State = HAL_OPAMP_STATE_BUSY;
     }
     else
     {
       status = HAL_ERROR;
     }
 
    }
   return status;
 }
 
 /**
   * @brief  Stop the OPAMP.
   * @param  hopamp OPAMP handle
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_OPAMP_Stop(OPAMP_HandleTypeDef *hopamp)
 {
   HAL_StatusTypeDef status = HAL_OK;
 
   /* Check the OPAMP handle allocation */
   /* Check if OPAMP locked */
   /* Check if OPAMP calibration ongoing */
   if(hopamp == NULL)
   {
     status = HAL_ERROR;
   }
   else if(hopamp->State == HAL_OPAMP_STATE_BUSYLOCKED)
   {
     status = HAL_ERROR;
   }
   else if(hopamp->State == HAL_OPAMP_STATE_CALIBBUSY)
   {
     status = HAL_ERROR;
   }
   else
   {
     /* Check the parameter */
     assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
 
     if(hopamp->State == HAL_OPAMP_STATE_BUSY)
     {
       /* Disable the selected opamp */
       CLEAR_BIT (hopamp->Instance->CSR, OPAMP_CSR_OPAMPxEN);
 
       /* Update the OPAMP state*/
       /* From  HAL_OPAMP_STATE_BUSY to HAL_OPAMP_STATE_READY*/
       hopamp->State = HAL_OPAMP_STATE_READY;
     }
     else
     {
       status = HAL_ERROR;
     }
   }
   return status;
 }
 
 /**
   * @brief  Run the self calibration of one OPAMP.
   * @note   Calibration is performed in the mode specified in OPAMP init
   *         structure (mode normal or high-speed). To perform calibration for
   *         both modes, repeat this function twice after OPAMP init structure
   *         accordingly updated.
   * @param  hopamp handle
   * @retval Updated offset trimming values (PMOS & NMOS), user trimming is enabled
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_OPAMP_SelfCalibrate(OPAMP_HandleTypeDef *hopamp)
 {
 
   HAL_StatusTypeDef status = HAL_OK;
 
   uint32_t trimmingvaluen;
   uint32_t trimmingvaluep;
   uint32_t delta;
   uint32_t opampmode;
 
   __IO uint32_t* tmp_opamp_reg_trimming;   /* Selection of register of trimming depending on power mode: OTR or HSOTR */
 
   /* Check the OPAMP handle allocation */
   /* Check if OPAMP locked */
   if(hopamp == NULL)
   {
     status = HAL_ERROR;
   }
   else if(hopamp->State == HAL_OPAMP_STATE_BUSYLOCKED)
   {
     status = HAL_ERROR;
   }
   else
   {
 
     /* Check if OPAMP in calibration mode and calibration not yet enable */
     if(hopamp->State ==  HAL_OPAMP_STATE_READY)
     {
       /* Check the parameter */
       assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
       assert_param(IS_OPAMP_POWERMODE(hopamp->Init.PowerMode));
 
       opampmode = READ_BIT(hopamp->Instance->CSR,OPAMP_CSR_VMSEL);
 
       /* Use of standalone mode */
       MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_VMSEL, OPAMP_STANDALONE_MODE);
       /*  user trimming values are used for offset calibration */
       SET_BIT(hopamp->Instance->CSR, OPAMP_CSR_USERTRIM);
 
       /* Select trimming settings depending on power mode */
       if (hopamp->Init.PowerMode == OPAMP_POWERMODE_NORMAL)
       {
         tmp_opamp_reg_trimming = &hopamp->Instance->OTR;
 
       }
       else
       {
         /* high speed Mode */
         tmp_opamp_reg_trimming = &hopamp->Instance->HSOTR;
       }
 
 
       /* Enable calibration */
       SET_BIT (hopamp->Instance->CSR, OPAMP_CSR_CALON);
 
       /* Force internal reference on VP */
       SET_BIT (hopamp->Instance->CSR, OPAMP_CSR_FORCEVP);
 
       /* 1st calibration - N */
       MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_CALSEL, OPAMP_VREF_90VDDA);
 
       /* Enable the selected opamp */
       SET_BIT (hopamp->Instance->CSR, OPAMP_CSR_OPAMPxEN);
 
       /* Init trimming counter */
       /* Medium value */
       trimmingvaluen = 16U;
       delta = 8U;
 
       while (delta != 0U)
       {
         /* Set candidate trimming */
         /* OPAMP_POWERMODE_NORMAL */
         MODIFY_REG(*tmp_opamp_reg_trimming, OPAMP_OTR_TRIMOFFSETN, trimmingvaluen);
 
         /* OFFTRIMmax delay 2 ms as per datasheet (electrical characteristics */
         /* Offset trim time: during calibration, minimum time needed between */
         /* two steps to have 1 mV accuracy */
         HAL_Delay(OPAMP_TRIMMING_DELAY);
 
         if (READ_BIT(hopamp->Instance->CSR, OPAMP_CSR_CALOUT) != 0U)
         {
           /* OPAMP_CSR_CALOUT is HIGH try higher trimming */
           trimmingvaluen += delta;
         }
         else
         {
           /* OPAMP_CSR_CALOUT is LOW try lower trimming */
           trimmingvaluen -= delta;
         }
         /* Divide range by 2 to continue dichotomy sweep */
         delta >>= 1;
       }
 
       /* Still need to check if right calibration is current value or one step below */
       /* Indeed the first value that causes the OUTCAL bit to change from 1  to 0  */
 
       MODIFY_REG(*tmp_opamp_reg_trimming, OPAMP_OTR_TRIMOFFSETN, trimmingvaluen);
 
       /* OFFTRIMmax delay 2 ms as per datasheet (electrical characteristics */
       /* Offset trim time: during calibration, minimum time needed between */
       /* two steps to have 1 mV accuracy */
       HAL_Delay(OPAMP_TRIMMING_DELAY);
 
       if ((READ_BIT(hopamp->Instance->CSR, OPAMP_CSR_CALOUT)) != 0U)
       {
         /* Trimming value is actually one value more */
         trimmingvaluen++;
         /* Set right trimming */
         MODIFY_REG(*tmp_opamp_reg_trimming, OPAMP_OTR_TRIMOFFSETN, trimmingvaluen);
       }
 
       /* 2nd calibration - P */
       MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_CALSEL, OPAMP_VREF_10VDDA);
 
       /* Init trimming counter */
       /* Medium value */
       trimmingvaluep = 16U;
       delta = 8U;
 
       while (delta != 0U)
       {
         /* Set candidate trimming */
         /* OPAMP_POWERMODE_NORMAL */
         MODIFY_REG(*tmp_opamp_reg_trimming, OPAMP_OTR_TRIMOFFSETP, (trimmingvaluep<<OPAMP_INPUT_NONINVERTING));
 
         /* OFFTRIMmax delay 2 ms as per datasheet (electrical characteristics */
         /* Offset trim time: during calibration, minimum time needed between */
         /* two steps to have 1 mV accuracy */
         HAL_Delay(OPAMP_TRIMMING_DELAY);
 
         if (READ_BIT(hopamp->Instance->CSR, OPAMP_CSR_CALOUT)!= 0U)
         {
           /* OPAMP_CSR_CALOUT is HIGH try higher trimming */
           trimmingvaluep += delta;
         }
         else
         {
           /* OPAMP_CSR_CALOUT  is LOW try lower trimming */
           trimmingvaluep -= delta;
         }
 
         /* Divide range by 2 to continue dichotomy sweep */
         delta >>= 1U;
       }
 
       /* Still need to check if right calibration is current value or one step below */
       /* Indeed the first value that causes the OUTCAL bit to change from 1 to 0  */
       /* Set candidate trimming */
       MODIFY_REG(*tmp_opamp_reg_trimming, OPAMP_OTR_TRIMOFFSETP, (trimmingvaluep<<OPAMP_INPUT_NONINVERTING));
 
       /* OFFTRIMmax delay 2 ms as per datasheet (electrical characteristics */
       /* Offset trim time: during calibration, minimum time needed between */
       /* two steps to have 1 mV accuracy */
       HAL_Delay(OPAMP_TRIMMING_DELAY);
 
       if (READ_BIT(hopamp->Instance->CSR, OPAMP_CSR_CALOUT) != 0U)
       {
         /* Trimming value is actually one value more */
         trimmingvaluep++;
         MODIFY_REG(*tmp_opamp_reg_trimming, OPAMP_OTR_TRIMOFFSETP, (trimmingvaluep<<OPAMP_INPUT_NONINVERTING));
       }
 
       /* Disable calibration & set normal mode (operating mode) */
       CLEAR_BIT (hopamp->Instance->CSR, OPAMP_CSR_CALON);
 
       /* Disable the OPAMP */
       CLEAR_BIT (hopamp->Instance->CSR, OPAMP_CSR_OPAMPxEN);
 
       /* Set operating mode back */
       CLEAR_BIT(hopamp->Instance->CSR, OPAMP_CSR_FORCEVP);
 
       /* Self calibration is successful  */
       /* Store calibration(user trimming) results in init structure. */
 
       /* Set user trimming mode */
       hopamp->Init.UserTrimming = OPAMP_TRIMMING_USER;
 
       /* Affect calibration parameters depending on mode normal/high speed */
       if (hopamp->Init.PowerMode != OPAMP_POWERMODE_HIGHSPEED)
       {
         /* Write calibration result N */
         hopamp->Init.TrimmingValueN = trimmingvaluen;
         /* Write calibration result P */
         hopamp->Init.TrimmingValueP = trimmingvaluep;
       }
       else
       {
         /* Write calibration result N */
         hopamp->Init.TrimmingValueNHighSpeed = trimmingvaluen;
         /* Write calibration result P */
         hopamp->Init.TrimmingValuePHighSpeed = trimmingvaluep;
       }
     /* Restore OPAMP mode after calibration */
     MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_VMSEL, opampmode);
     }
 
     else
     {
       /* OPAMP can not be calibrated from this mode */
       status = HAL_ERROR;
     }
   }
   return status;
 }
 
 /**
   * @}
   */
 
 /** @defgroup OPAMP_Exported_Functions_Group3 Peripheral Control functions
   * @ingroup RTEMSBSPsARMSTM32H7
  *  @brief   Peripheral Control functions
  *
 @verbatim
  ===============================================================================
                       ##### Peripheral Control functions #####
  ===============================================================================
     [..]
     This subsection provides a set of functions allowing to control the OPAMP data
     transfers.
 
 
 
 @endverbatim
   * @{
   */
 
 /**
   * @brief  Lock the selected OPAMP configuration.
   * @note   On STM32H7, HAL OPAMP lock is software lock only (in
   *         contrast of hardware lock available on some other STM32
   *         devices)
   * @param  hopamp OPAMP handle
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_OPAMP_Lock(OPAMP_HandleTypeDef *hopamp)
 {
   HAL_StatusTypeDef status = HAL_OK;
 
   /* Check the OPAMP handle allocation */
   /* Check if OPAMP locked */
   /* OPAMP can be locked when enabled and running in normal mode */
   /*   It is meaningless otherwise */
   if(hopamp == NULL)
   {
     status = HAL_ERROR;
   }
 
   else if(hopamp->State != HAL_OPAMP_STATE_BUSY)
   {
     status = HAL_ERROR;
   }
   else
   {
     /* Check the parameter */
     assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
 
    /* OPAMP state changed to locked */
     hopamp->State = HAL_OPAMP_STATE_BUSYLOCKED;
   }
   return status;
 }
 
 /**
   * @brief  Return the OPAMP factory trimming value.
   * @note            On STM32H7 OPAMP, user can retrieve factory trimming if
   *                  OPAMP has never been set to user trimming before.
   *                  Therefore, this function must be called when OPAMP init
   *                  parameter "UserTrimming" is set to trimming factory,
   *                  and before OPAMP  calibration (function
   *                  "HAL_OPAMP_SelfCalibrate()").
   *                  Otherwise, factory trimming value cannot be retrieved and
   *                  error status is returned.
   * @param  hopamp  OPAMP handle
   * @param  trimmingoffset  Trimming offset (P or N)
   *         This parameter must be a value of @ref OPAMP_FactoryTrimming
   * @note   Calibration parameter retrieved is corresponding to the mode
   *         specified in OPAMP init structure (mode normal or high-speed).
   *         To retrieve calibration parameters for both modes, repeat this
   *         function after OPAMP init structure accordingly updated.
   * @retval Trimming value (P or N): range: 0->31
   *         or OPAMP_FACTORYTRIMMING_DUMMY if trimming value is not available
   *
   */
 HAL_OPAMP_TrimmingValueTypeDef HAL_OPAMP_GetTrimOffset (OPAMP_HandleTypeDef *hopamp, uint32_t trimmingoffset)
 {
   HAL_OPAMP_TrimmingValueTypeDef trimmingvalue;
   __IO uint32_t* tmp_opamp_reg_trimming;  /* Selection of register of trimming depending on power mode: OTR or LPOTR */
 
   /* Check the OPAMP handle allocation */
   /* Value can be retrieved in HAL_OPAMP_STATE_READY state */
   if(hopamp == NULL)
   {
     return OPAMP_FACTORYTRIMMING_DUMMY;
   }
 
   if(hopamp->State == HAL_OPAMP_STATE_READY)
   {
     /* Check the parameter */
     assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
     assert_param(IS_OPAMP_FACTORYTRIMMING(trimmingoffset));
     assert_param(IS_OPAMP_POWERMODE(hopamp->Init.PowerMode));
 
     /* Check the trimming mode */
     if (READ_BIT(hopamp->Instance->CSR,OPAMP_CSR_USERTRIM)!= 0U)
     {
       /* This function must called when OPAMP init parameter "UserTrimming"   */
       /* is set to trimming factory, and before OPAMP calibration (function   */
       /* "HAL_OPAMP_SelfCalibrate()").                                        */
       /* Otherwise, factory trimming value cannot be retrieved and error       */
       /* status is returned.                                                  */
       trimmingvalue = OPAMP_FACTORYTRIMMING_DUMMY;
     }
     else
     {
       /* Select trimming settings depending on power mode */
       if (hopamp->Init.PowerMode == OPAMP_POWERMODE_NORMAL)
       {
         tmp_opamp_reg_trimming = &hopamp->Instance->OTR;
       }
       else
       {
         tmp_opamp_reg_trimming = &hopamp->Instance->HSOTR;
       }
 
       /* Get factory trimming  */
       if (trimmingoffset == OPAMP_FACTORYTRIMMING_P)
       {
         /* OPAMP_FACTORYTRIMMING_P */
         trimmingvalue = ((*tmp_opamp_reg_trimming) & OPAMP_OTR_TRIMOFFSETP) >> OPAMP_INPUT_NONINVERTING;
       }
       else
       {
         /* OPAMP_FACTORYTRIMMING_N */
         trimmingvalue = (*tmp_opamp_reg_trimming) & OPAMP_OTR_TRIMOFFSETN;
       }
     }
   }
   else
   {
     return OPAMP_FACTORYTRIMMING_DUMMY;
   }
 
   return trimmingvalue;
 }
 
 #if (USE_HAL_OPAMP_REGISTER_CALLBACKS == 1)
 /**
   * @brief  Register a User OPAMP Callback
   *         To be used instead of the weak (overridden) predefined callback
   * @param hopamp  OPAMP handle
   * @param CallbackId  ID of the callback to be registered
   *        This parameter can be one of the following values:
   *          @arg @ref HAL_OPAMP_MSPINIT_CB_ID       OPAMP MspInit callback ID
   *          @arg @ref HAL_OPAMP_MSPDEINIT_CB_ID     OPAMP MspDeInit callback ID
   * @param pCallback  pointer to the Callback function
   * @retval status
   */
 HAL_StatusTypeDef HAL_OPAMP_RegisterCallback (OPAMP_HandleTypeDef *hopamp, HAL_OPAMP_CallbackIDTypeDef CallbackId, pOPAMP_CallbackTypeDef pCallback)
 {
   HAL_StatusTypeDef status = HAL_OK;
 
   if(pCallback == NULL)
   {
     return HAL_ERROR;
   }
 
   /* Process locked */
   __HAL_LOCK(hopamp);
 
   if(hopamp->State == HAL_OPAMP_STATE_READY)
   {
     switch (CallbackId)
     {
     case HAL_OPAMP_MSPINIT_CB_ID :
       hopamp->MspInitCallback = pCallback;
       break;
     case HAL_OPAMP_MSPDEINIT_CB_ID :
       hopamp->MspDeInitCallback = pCallback;
       break;
     default :
       /* update return status */
       status =  HAL_ERROR;
       break;
     }
   }
   else if (hopamp->State == HAL_OPAMP_STATE_RESET)
   {
     switch (CallbackId)
     {
     case HAL_OPAMP_MSPINIT_CB_ID :
       hopamp->MspInitCallback = pCallback;
       break;
     case HAL_OPAMP_MSPDEINIT_CB_ID :
       hopamp->MspDeInitCallback = pCallback;
       break;
     default :
       /* update return status */
       status =  HAL_ERROR;
       break;
     }
   }
   else
   {
     /* update return status */
     status =  HAL_ERROR;
   }
 
   /* Release Lock */
   __HAL_UNLOCK(hopamp);
   return status;
 }
 
 /**
   * @brief  Unregister a User OPAMP Callback
   *         OPAMP Callback is redirected to the weak (overridden) predefined callback
   * @param hopamp  OPAMP handle
   * @param CallbackId  ID of the callback to be unregistered
   *        This parameter can be one of the following values:
   *          @arg @ref HAL_OPAMP_MSPINIT_CB_ID    OPAMP MSP Init Callback ID
   *          @arg @ref HAL_OPAMP_MSPDEINIT_CB_ID  OPAMP MSP DeInit Callback ID
   *          @arg @ref HAL_OPAMP_ALL_CB_ID        OPAMP All Callbacks
   * @retval status
   */
 HAL_StatusTypeDef HAL_OPAMP_UnRegisterCallback (OPAMP_HandleTypeDef *hopamp, HAL_OPAMP_CallbackIDTypeDef CallbackId)
 {
   HAL_StatusTypeDef status = HAL_OK;
 
   /* Process locked */
   __HAL_LOCK(hopamp);
 
   if(hopamp->State == HAL_OPAMP_STATE_READY)
   {
     switch (CallbackId)
     {
     case HAL_OPAMP_MSPINIT_CB_ID :
       hopamp->MspInitCallback = HAL_OPAMP_MspInit;
       break;
     case HAL_OPAMP_MSPDEINIT_CB_ID :
       hopamp->MspDeInitCallback = HAL_OPAMP_MspDeInit;
       break;
     case HAL_OPAMP_ALL_CB_ID :
       hopamp->MspInitCallback = HAL_OPAMP_MspInit;
       hopamp->MspDeInitCallback = HAL_OPAMP_MspDeInit;
       break;
     default :
       /* update return status */
       status =  HAL_ERROR;
       break;
     }
   }
   else if (hopamp->State == HAL_OPAMP_STATE_RESET)
   {
     switch (CallbackId)
     {
     case HAL_OPAMP_MSPINIT_CB_ID :
       hopamp->MspInitCallback = HAL_OPAMP_MspInit;
       break;
     case HAL_OPAMP_MSPDEINIT_CB_ID :
       hopamp->MspDeInitCallback = HAL_OPAMP_MspDeInit;
       break;
     default :
       /* update return status */
       status =  HAL_ERROR;
       break;
     }
   }
   else
   {
     /* update return status */
     status =  HAL_ERROR;
   }
 
   /* Release Lock */
   __HAL_UNLOCK(hopamp);
   return status;
 }
 
 #endif /* USE_HAL_OPAMP_REGISTER_CALLBACKS */
 
 /**
   * @}
   */
 
 
 /** @defgroup OPAMP_Exported_Functions_Group4 Peripheral State functions
   * @ingroup RTEMSBSPsARMSTM32H7
   *  @brief   Peripheral State functions
   *
 @verbatim
  ===============================================================================
                       ##### Peripheral State functions #####
  ===============================================================================
     [..]
     This subsection permits to get in run-time the status of the peripheral.
 
 @endverbatim
   * @{
   */
 
 /**
   * @brief  Return the OPAMP handle state.
   * @param  hopamp  OPAMP handle
   * @retval HAL state
   */
 HAL_OPAMP_StateTypeDef HAL_OPAMP_GetState(OPAMP_HandleTypeDef *hopamp)
 {
   /* Check the OPAMP handle allocation */
   if(hopamp == NULL)
   {
     return HAL_OPAMP_STATE_RESET;
   }
 
   /* Check the parameter */
   assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
 
   /* Return OPAMP handle state */
   return hopamp->State;
 }
 
 /**
   * @}
   */
 
 /**
   * @}
   */
 #endif /* HAL_OPAMP_MODULE_ENABLED */
 /**
   * @}
   */
 
 /**
   * @}
   */
 

This page was automatically generated by the 2.3.7 LXR engine. The LXR team