Subversion Repositories DashDisplay

/**

  ******************************************************************************

  * @file    stm32l1xx_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:

  *           + OPAMP configuration

  *           + OPAMP calibration

  *          Thanks to

  *           + Initialization and de-initialization functions

  *           + IO operation functions

  *           + Peripheral Control functions

  *           + Peripheral State functions

  *        

  @verbatim

================================================================================

          ##### OPAMP Peripheral Features #####

================================================================================

  [..] The device integrates up to 3 operational amplifiers OPAMP1, OPAMP2,

       OPAMP3 (OPAMP3 availability depends on device category)

       (#) The OPAMP(s) provide(s) several exclusive running modes.

       (++) Standalone mode

       (++) Follower mode

       (#) All OPAMP (same for all OPAMPs) can operate in

       (++) Either Low range (VDDA < 2.4V) power supply

       (++) Or High range (VDDA > 2.4V) power supply

       (#) Each OPAMP(s) can be configured in normal and low power 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: for transistors

            differential pair high (PMOS) or low (NMOS)

       (+++) 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)

       (+++) For devices having several OPAMPs, 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.

       (++) The OPAMP(s) output(s) are internally connected to inverting input.

            ##### How to use this driver #####

================================================================================

  [..]

    *** Power supply range ***

    ============================================

    [..] To run in low power mode:

      (#) Configure the OPAMP using HAL_OPAMP_Init() function:

      (++) Select OPAMP_POWERSUPPLY_LOW (VDDA lower than 2.4V)

      (++) Otherwise select OPAMP_POWERSUPPLY_HIGH (VDDA higher than 2.4V)

    *** Low / normal power mode ***

    ============================================

    [..] To run in low power mode:

      (#) Configure the OPAMP using HAL_OPAMP_Init() function:

      (++) Select OPAMP_POWERMODE_LOWPOWER

      (++) 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 @ref HAL_OPAMP_RegisterCallback() to register a user callback,

           it allows to register following callbacks:

      (+++) MspInitCallback         : OPAMP MspInit.

      (+++) MspDeInitCallback       : OPAMP MspFeInit.

           This function takes as parameters the HAL peripheral handle, the Callback ID

           and a pointer to the user callback function.

      (++) Use function @ref HAL_OPAMP_UnRegisterCallback() to reset a callback to the default

           weak (surcharged) 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

      (++) 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 STM32L1, 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 low power 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

  ******************************************************************************

  * @attention

  *

  * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.

  * All rights reserved.</center></h2>

  *

  * This software component is licensed by ST under BSD 3-Clause license,

  * the "License"; You may not use this file except in compliance with the

  * License. You may obtain a copy of the License at:

  *                        opensource.org/licenses/BSD-3-Clause

  *

  ******************************************************************************  

  */

/*

  Additionnal remark:

    The OPAMPs inverting input can be selected among the list shown by table below.

    The OPAMPs non inverting input can be selected among the list shown by table below.

    Table 1.  OPAMPs inverting/non-inverting inputs for STM32L1 devices:

    +--------------------------------------------------------------------------+

    |                | HAL param  |    OPAMP1    |    OPAMP2    |   OPAMP3(4)  |

    |                |   name     |              |              |              |

    |----------------|------------|--------------|--------------|--------------|

    |   Inverting    |    VM0     |     PA2      |     PA7      |     PC2      |

    |    input (1)   |    VM1     | VINM pin (2) | VINM pin (2) | VINM pin (2) |

    |----------------|------------|--------------|--------------|--------------|

    |  Non Inverting |    VP0     |     PA1      |     PA6      |     PC1      |

    |    input       | DAC_CH1 (3)|   DAC_CH1    |   DAC_CH1    |     ---      |

    |                | DAC_CH2 (3)|     ---      |   DAC_CH2    |   DAC_CH2    |

    +--------------------------------------------------------------------------+

    (1): NA in follower mode.

    (2): OPAMP input OPAMPx_VINM are dedicated OPAMP pins, their availability

         depends on device package.

    (3): DAC channels 1 and 2 are connected internally to OPAMP. Nevertheless,

         I/O pins connected to DAC can still be used as DAC output (pins PA4

         and PA5).

    (4): OPAMP3 availability depends on device category.

    Table 2.  OPAMPs outputs for STM32L1 devices:

    +--------------------------------------------------------+

    |                 |   OPAMP1   |   OPAMP2   |  OPAMP3(4) |

    |-----------------|------------|------------|------------|

    | Output          |    PA3     |    PB0     |    PC3     |

    +--------------------------------------------------------+

    (4) : OPAMP3 availability depends on device category

*/

/* Includes ------------------------------------------------------------------*/

#include "stm32l1xx_hal.h"

/** @addtogroup STM32L1xx_HAL_Driver

  * @{

  */

/** @defgroup OPAMP OPAMP

  * @brief OPAMP module driver

  * @{

  */

#ifdef HAL_OPAMP_MODULE_ENABLED

#if defined (STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined (STM32L151xE) || defined (STM32L151xDX) || defined (STM32L152xE) || defined (STM32L152xDX) || defined (STM32L162xE) || defined (STM32L162xDX) || defined (STM32L162xC) || defined (STM32L152xC) || defined (STM32L151xC)

/* Private typedef -----------------------------------------------------------*/

/* Private define ------------------------------------------------------------*/

/* Private macro -------------------------------------------------------------*/

/* Private variables ---------------------------------------------------------*/

/* Private constants ---------------------------------------------------------*/

/* Private function prototypes -----------------------------------------------*/

/* Private functions ---------------------------------------------------------*/

/* Exported functions --------------------------------------------------------*/

/** @defgroup OPAMP_Exported_Functions OPAMP Exported Functions

  * @{

  */

/** @defgroup OPAMP_Exported_Functions_Group1 Initialization and de-initialization functions

 *  @brief    Initialization and Configuration functions

 *

@verbatim    

  ==============================================================================

              ##### Initialization and de-initialization functions #####

  ==============================================================================

   [..]  This section provides functions allowing to:

@endverbatim

  * @{

  */

/**

  * @brief  Initializes the OPAMP according to the specified

  *         parameters in the OPAMP_InitTypeDef and create 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 tmp_csr;       /* Temporary variable to update register CSR, except bits ANAWSSELx, S7SEL2, OPA_RANGE, OPAxCALOUT */

  /* 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_POWER_SUPPLY_RANGE(hopamp->Init.PowerSupplyRange));

    assert_param(IS_OPAMP_POWERMODE(hopamp->Init.PowerMode));

    assert_param(IS_OPAMP_FUNCTIONAL_NORMALMODE(hopamp->Init.Mode));

    assert_param(IS_OPAMP_NONINVERTING_INPUT_CHECK_INSTANCE(hopamp, hopamp->Init.NonInvertingInput));

    assert_param(IS_OPAMP_TRIMMING(hopamp->Init.UserTrimming));

#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_FOLLOWER_MODE)

    {

      assert_param(IS_OPAMP_INVERTING_INPUT(hopamp->Init.InvertingInput));

    }

    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.TrimmingValuePLowPower));

        assert_param(IS_OPAMP_TRIMMINGVALUE(hopamp->Init.TrimmingValueNLowPower));

      }

    }

    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 OPAMP parameters                                                   */

    /* - Set internal switches in function of:                                */

    /*   - OPAMP selected mode: standalone or follower.                       */

    /*   - Non-inverting input connection                                     */

    /*   - Inverting input connection                                         */

    /* - Set power supply range                                               */

    /* - Set power mode and associated calibration parameters                 */

    /* Get OPAMP CSR register into temporary variable */

    /* Note: OPAMP register CSR is written directly, independently of OPAMP   */

    /*       instance, because all OPAMP settings are dispatched in the same  */

    /*       register.                                                        */

    /*       Settings of bits for each OPAMP instances are managed case by    */

    /*       case using macro (OPAMP_CSR_S3SELX(), OPAMP_CSR_ANAWSELX(), ...) */

    tmp_csr = OPAMP->CSR;

    /* Open all switches on non-inverting input, inverting input and output   */

    /* feedback.                                                              */

    CLEAR_BIT(tmp_csr, OPAMP_CSR_ALL_SWITCHES(hopamp));

    /* Set internal switches in function of OPAMP mode selected: standalone   */

    /* or follower.                                                           */

    /* If follower mode is selected, feedback switch S3 is closed and         */

    /* inverting inputs switches are let opened.                              */

    /* If standalone mode is selected, feedback switch S3 is let opened and   */

    /* the selected inverting inputs switch is closed.                        */

    if (hopamp->Init.Mode == OPAMP_FOLLOWER_MODE)

    {

      /* Follower mode: Close switches S3 and SanB */

      SET_BIT(tmp_csr, OPAMP_CSR_S3SELX(hopamp));

    }

    else

    {

      /* Set internal switches in function of inverting input selected:       */

      /* Close switch to connect OPAMP inverting input to the selected        */

      /* input: dedicated IO pin or alternative IO pin available on some      */

      /* device packages.                                                     */

      if (hopamp->Init.InvertingInput == OPAMP_INVERTINGINPUT_IO0)

      {

        /* Close switch to connect OPAMP non-inverting input to               */

        /* dedicated IO pin low-leakage.                                      */

        SET_BIT(tmp_csr, OPAMP_CSR_S4SELX(hopamp));

      }

      else

      {

        /* Close switch to connect OPAMP inverting input to alternative       */

        /* IO pin available on some device packages.                          */

        SET_BIT(tmp_csr, OPAMP_CSR_ANAWSELX(hopamp));

      }

    }

    /* Set internal switches in function of non-inverting input selected:     */

    /* Close switch to connect OPAMP non-inverting input to the selected      */

    /* input: dedicated IO pin or DAC channel.                                */

    if (hopamp->Init.NonInvertingInput == OPAMP_NONINVERTINGINPUT_IO0)

    {

      /* Close switch to connect OPAMP non-inverting input to                 */

      /* dedicated IO pin low-leakage.                                        */

      SET_BIT(tmp_csr, OPAMP_CSR_S5SELX(hopamp));

    }

    else if (hopamp->Init.NonInvertingInput == OPAMP_NONINVERTINGINPUT_DAC_CH1)

    {

      /* Particular case for connection to DAC channel 1:                     */

      /* OPAMP_NONINVERTINGINPUT_DAC_CH1 available on OPAMP1 and OPAMP2 only  */

      /* (OPAMP3 availability depends on device category).                    */

      if ((hopamp->Instance == OPAMP1) || (hopamp->Instance == OPAMP2))

      {

        /* Close switch to connect OPAMP non-inverting input to               */

        /* DAC channel 1.                                                     */

        SET_BIT(tmp_csr, OPAMP_CSR_S6SELX(hopamp));

      }

      else

      {

        /* Set HAL status to error if another OPAMP instance as OPAMP1 or     */

        /* OPAMP2 is intended to be connected to DAC channel 2.               */

        status = HAL_ERROR;

      }

    }

    else /* if (hopamp->Init.NonInvertingInput ==                             */

         /*     OPAMP_NONINVERTINGINPUT_DAC_CH2  )                            */

    {

      /* Particular case for connection to DAC channel 2:                     */

      /* OPAMP_NONINVERTINGINPUT_DAC_CH2 available on OPAMP2 and OPAMP3 only  */

      /* (OPAMP3 availability depends on device category).                    */

      if (hopamp->Instance == OPAMP2)

      {

        /* Close switch to connect OPAMP non-inverting input to               */

        /* DAC channel 2.                                                     */

        SET_BIT(tmp_csr, OPAMP_CSR_S7SEL2);

      }

      /* If OPAMP3 is selected (if available) */

      else if (hopamp->Instance != OPAMP1)

      {

        /* Close switch to connect OPAMP non-inverting input to               */

        /* DAC channel 2.                                                     */

        SET_BIT(tmp_csr, OPAMP_CSR_S6SELX(hopamp));

      }

      else

      {

        /* Set HAL status to error if another OPAMP instance as OPAMP2 or     */

        /* OPAMP3 (if available) is intended to be connected to DAC channel 2.*/

        status = HAL_ERROR;

      }

    }

    /* Continue OPAMP configuration if settings of switches are correct */

    if (status != HAL_ERROR)

    {

      /* Set power mode and associated calibration parameters */

      if (hopamp->Init.PowerMode != OPAMP_POWERMODE_LOWPOWER)

      {

        /* Set normal mode */

        CLEAR_BIT(tmp_csr, OPAMP_CSR_OPAXLPM(hopamp));

        if (hopamp->Init.UserTrimming == OPAMP_TRIMMING_USER)

        {

          /* Set calibration mode (factory or user) and values for            */

          /* transistors differential pair high (PMOS) and low (NMOS) for     */

          /* normal mode.                                                     */

          MODIFY_REG(OPAMP->OTR, OPAMP_OTR_OT_USER                                                                     |

                                 OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_N, OPAMP_TRIM_VALUE_MASK)       |

                                 OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_P, OPAMP_TRIM_VALUE_MASK)        ,

                                 hopamp->Init.UserTrimming                                                             |

                                 OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_N, hopamp->Init.TrimmingValueN) |

                                 OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_P, hopamp->Init.TrimmingValueP)  );

        }

        else

        {

          /* Set calibration mode to factory */

          CLEAR_BIT(OPAMP->OTR, OPAMP_OTR_OT_USER);

        }

      }

      else

      {

        /* Set low power mode */

        SET_BIT(tmp_csr, OPAMP_CSR_OPAXLPM(hopamp));

        if (hopamp->Init.UserTrimming == OPAMP_TRIMMING_USER)

        {

          /* Set calibration mode to user trimming */

          SET_BIT(OPAMP->OTR, OPAMP_OTR_OT_USER);

          /* Set values for transistors differential pair high (PMOS) and low */

          /* (NMOS) for low power mode.                                       */

          MODIFY_REG(OPAMP->LPOTR, OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_N, OPAMP_TRIM_VALUE_MASK)               |

                                   OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_P, OPAMP_TRIM_VALUE_MASK)                ,

                                   OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_N, hopamp->Init.TrimmingValueNLowPower) |

                                   OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_P, hopamp->Init.TrimmingValuePLowPower)  );

        }

        else

        {

          /* Set calibration mode to factory trimming */

          CLEAR_BIT(OPAMP->OTR, OPAMP_OTR_OT_USER);

        }

      }

      /* Configure the power supply range */

      MODIFY_REG(tmp_csr, OPAMP_CSR_AOP_RANGE,

                          hopamp->Init.PowerSupplyRange);

      /* Set OPAMP CSR register from temporary variable */

      /* This allows to apply all changes on one time, in case of update on   */

      /* the fly with OPAMP previously set and running:                       */

      /*  - to avoid hazardous transient switches settings (risk of short     */

      /*    circuit)                                                          */

      /*  - to avoid interruption of input signal                             */

      OPAMP->CSR = tmp_csr;

      /* Update the OPAMP state */

      /* If coming from state reset: Update from state RESET to state READY */

      if (hopamp->State == HAL_OPAMP_STATE_RESET)

      {

        hopamp->State = HAL_OPAMP_STATE_READY;

      }

      /* else: OPAMP state remains READY or BUSY state (no update) */

    }

  }

  return status;

}

/**

  * @brief  DeInitializes the OPAMP peripheral

  * @note   Deinitialization can be performed if the OPAMP configuration is locked.

  *         (the OPAMP lock is SW in STM32L1)

  * @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 ongoing */

  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));

    /* Disable the selected opamp */

    SET_BIT (OPAMP->CSR, OPAMP_CSR_OPAXPD(hopamp));

    /* Open all switches on non-inverting input, inverting input and output   */

    /* feedback.                                                              */

    /* Note: OPAMP register CSR is written directly, independently of OPAMP   */

    /*       instance, because all OPAMP settings are dispatched in the same  */

    /*       register.                                                        */

    /*       Settings of bits for each OPAMP instances are managed case by    */

    /*       case using macro (OPAMP_CSR_S3SELX(), OPAMP_CSR_ANAWSELX(), ...) */

    CLEAR_BIT(OPAMP->CSR, OPAMP_CSR_ALL_SWITCHES(hopamp));

    /* Note: Registers and bits shared with other OPAMP instances are kept    */

    /*       unchanged, to not impact other OPAMP while operating on the      */

    /*       selected OPAMP.                                                  */

    /*       Unchanged: bit OPAMP_OTR_OT_USER (parameter "UserTrimming")      */

    /*                  bit OPAMP_CSR_AOP_RANGE (parameter "PowerSupplyRange")*/

#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

    /* DeInit the low level hardware: GPIO, CLOCK and NVIC */

    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

  * @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 */

      CLEAR_BIT (OPAMP->CSR, OPAMP_CSR_OPAXPD(hopamp));

      /* 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 */

      SET_BIT (OPAMP->CSR, OPAMP_CSR_OPAXPD(hopamp));

      /* 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   Trimming values (PMOS & NMOS) are updated and user trimming is

  *         enabled if calibration is succesful.

  * @note   Calibration is performed in the mode specified in OPAMP init

  *         structure (mode normal or low-power). To perform calibration for

  *         both modes, repeat this function twice after OPAMP init structure

  *         accordingly updated.

  * @note   Calibration runs about 10 ms.

  * @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* opamp_trimmingvalue;

  uint32_t opamp_trimmingvaluen = 0;

  uint32_t opamp_trimmingvaluep = 0;

  uint32_t trimming_diff_pair;               /* Selection of differential transistors pair high or low */

  __IO uint32_t* tmp_opamp_reg_trimming;     /* Selection of register of trimming depending on power mode: OTR or LPOTR */

  uint32_t tmp_opamp_otr_otuser;             /* Selection of bit OPAMP_OTR_OT_USER depending on trimming register pointed: OTR or LPOTR */

  uint32_t tmp_Opaxcalout_DefaultSate;       /* Bit OPAMP_CSR_OPAXCALOUT default state when trimming value is 00000b. Used to detect the bit toggling */

  uint32_t tmp_OpaxSwitchesContextBackup;

  uint8_t trimming_diff_pair_iteration_count;          /* For calibration loop algorithm: to repeat the calibration loop for both differential transistors pair high and low */

  uint8_t delta;                                       /* For calibration loop algorithm: Variable for dichotomy steps value */

  uint8_t final_step_check = 0x0U;                        /* For calibration loop algorithm: Flag for additional check of last trimming step */

  /* 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));

      /* Update OPAMP state */

      hopamp->State = HAL_OPAMP_STATE_CALIBBUSY;

      /* Backup of switches configuration to restore it at the end of the     */

      /* calibration.                                                         */

      tmp_OpaxSwitchesContextBackup = READ_BIT(OPAMP->CSR, OPAMP_CSR_ALL_SWITCHES(hopamp));

      /* Open all switches on non-inverting input, inverting input and output */

      /* feedback.                                                            */

      CLEAR_BIT(OPAMP->CSR, OPAMP_CSR_ALL_SWITCHES(hopamp));

      /* Set calibration mode to user programmed trimming values */

      SET_BIT(OPAMP->OTR, OPAMP_OTR_OT_USER);

      /* Select trimming settings depending on power mode */

      if (hopamp->Init.PowerMode == OPAMP_POWERMODE_NORMAL)

      {

        tmp_opamp_otr_otuser = OPAMP_OTR_OT_USER;

        tmp_opamp_reg_trimming = &OPAMP->OTR;

      }

      else

      {

        tmp_opamp_otr_otuser = 0x00000000U;

        tmp_opamp_reg_trimming = &OPAMP->LPOTR;

      }

      /* Enable the selected opamp */

      CLEAR_BIT (OPAMP->CSR, OPAMP_CSR_OPAXPD(hopamp));

      /* Perform trimming for both differential transistors pair high and low */

      for (trimming_diff_pair_iteration_count = 0U; trimming_diff_pair_iteration_count <=1U; trimming_diff_pair_iteration_count++)

      {

        if (trimming_diff_pair_iteration_count == 0U)

        {

          /* Calibration of transistors differential pair high (NMOS) */

          trimming_diff_pair = OPAMP_FACTORYTRIMMING_N;

          opamp_trimmingvalue = &opamp_trimmingvaluen;

          /* Set bit OPAMP_CSR_OPAXCALOUT default state when trimming value   */

          /* is 00000b. Used to detect the bit toggling during trimming.      */

          tmp_Opaxcalout_DefaultSate = 0U;

          /* Enable calibration for N differential pair */

          MODIFY_REG(OPAMP->CSR, OPAMP_CSR_OPAXCAL_L(hopamp),

                                 OPAMP_CSR_OPAXCAL_H(hopamp) );

        }

        else /* (trimming_diff_pair_iteration_count == 1) */

        {

          /* Calibration of transistors differential pair low (PMOS) */

          trimming_diff_pair = OPAMP_FACTORYTRIMMING_P;

          opamp_trimmingvalue = &opamp_trimmingvaluep;

          /* Set bit OPAMP_CSR_OPAXCALOUT default state when trimming value   */

          /* is 00000b. Used to detect the bit toggling during trimming.      */

          tmp_Opaxcalout_DefaultSate = OPAMP_CSR_OPAXCALOUT(hopamp);

          /* Enable calibration for P differential pair */

          MODIFY_REG(OPAMP->CSR, OPAMP_CSR_OPAXCAL_H(hopamp),

                                 OPAMP_CSR_OPAXCAL_L(hopamp) );

        }

        /* Perform calibration parameter search by dichotomy sweep */

        /*  - Delta initial value 16: for 5 dichotomy steps: 16 for the       */

        /*    initial range, then successive delta sweeps (8, 4, 2, 1).       */

        /*    can extend the search range to +/- 15 units.                    */

        /*  - Trimming initial value 15: search range will go from 0 to 30    */

        /*    (Trimming value 31 is forbidden).                               */

        /* Note: After dichotomy sweep, the trimming result is determined.    */

        /*       However, the final trimming step is deduced from previous    */

        /*       trimming steps tested but is not effectively tested.         */

        /*       An additional test step (using variable "final_step_check")  */

        /*       allow to Test the final trimming step.                       */

        *opamp_trimmingvalue = 15U;

        delta = 16U;

        while ((delta != 0U) || (final_step_check == 1U))

        {

          /* Set candidate trimming */

          MODIFY_REG(*tmp_opamp_reg_trimming, OPAMP_OFFSET_TRIM_SET(hopamp, trimming_diff_pair, OPAMP_TRIM_VALUE_MASK) ,

                                              OPAMP_OFFSET_TRIM_SET(hopamp, trimming_diff_pair, *opamp_trimmingvalue) | tmp_opamp_otr_otuser);

          /* Offset trimming time: during calibration, minimum time needed    */

          /* between two steps to have 1 mV accuracy.                         */

          HAL_Delay(OPAMP_TRIMMING_DELAY);

          /* Set flag for additional check of last trimming step equal to     */

          /* dichotomy step before its division by 2 (equivalent to previous  */

          /* value of dichotomy step).                                        */

          final_step_check = delta;

          /* Divide range by 2 to continue dichotomy sweep */

          delta >>= 1;

          /* Set trimming values for next iteration in function of trimming   */

          /* result toggle (versus initial state).                            */

          /* Note: on the last trimming loop, delta is equal to 0 and         */

          /*       therefore has no effect.                                   */

          if (READ_BIT(OPAMP->CSR, OPAMP_CSR_OPAXCALOUT(hopamp)) != tmp_Opaxcalout_DefaultSate)

          {

            /* If calibration output is has toggled, try lower trimming */

            *opamp_trimmingvalue -= delta;

          }

          else

          {

            /* If calibration output is has not toggled, try higher trimming */

            *opamp_trimmingvalue += delta;

          }

        }

        /* Check trimming result of the selected step and perform final fine  */

        /* trimming.                                                          */

        /*  - If calibration output is has toggled: the current step is       */

        /*    already optimized.                                              */

        /*  - If calibration output is has not toggled: the current step can  */

        /*    be optimized by incrementing it of one step.                    */

        if (READ_BIT(OPAMP->CSR, OPAMP_CSR_OPAXCALOUT(hopamp)) == tmp_Opaxcalout_DefaultSate)

        {

          *opamp_trimmingvalue += 1U;

          /* Set final fine trimming */

          MODIFY_REG(*tmp_opamp_reg_trimming, OPAMP_OFFSET_TRIM_SET(hopamp, trimming_diff_pair, OPAMP_TRIM_VALUE_MASK) ,

                                              OPAMP_OFFSET_TRIM_SET(hopamp, trimming_diff_pair, *opamp_trimmingvalue) | tmp_opamp_otr_otuser);

        }

      }

      /* Disable calibration for P and N differential pairs */

      /* Disable the selected opamp */

      CLEAR_BIT (OPAMP->CSR, (OPAMP_CSR_OPAXCAL_H(hopamp) |

                              OPAMP_CSR_OPAXCAL_L(hopamp) |

                              OPAMP_CSR_OPAXPD(hopamp))    );

      /* Backup of switches configuration to restore it at the end of the     */

      /* calibration.                                                         */

      SET_BIT(OPAMP->CSR, tmp_OpaxSwitchesContextBackup);

      /* Self calibration is successful */

      /* Store calibration (user trimming) results in init structure. */

      /* Set user trimming mode */  

      hopamp->Init.UserTrimming = OPAMP_TRIMMING_USER;

      /* Check on unsupported value */

      if(opamp_trimmingvaluep == 0x1FU)  /* 0x1F is not functional */

      {

        opamp_trimmingvaluep = 30U;

      }

      if(opamp_trimmingvaluen == 0x1FU)  /* 0x1F is not functional */

      {

        opamp_trimmingvaluen = 30U;