1 /**
2 ******************************************************************************
3 * @file stm32l1xx_hal_opamp.c
4 * @author MCD Application Team
5 * @brief OPAMP HAL module driver.
6 * This file provides firmware functions to manage the following
7 * functionalities of the operational amplifier(s) peripheral:
8 * + Initialization and de-initialization functions
9 * + IO operation functions
10 * + Peripheral Control functions
11 * + Peripheral State functions
12 *
13 ******************************************************************************
14 * @attention
15 *
16 * Copyright (c) 2017 STMicroelectronics.
17 * All rights reserved.
18 *
19 * This software is licensed under terms that can be found in the LICENSE file
20 * in the root directory of this software component.
21 * If no LICENSE file comes with this software, it is provided AS-IS.
22 *
23 ******************************************************************************
24 @verbatim
25 ================================================================================
26 ##### OPAMP Peripheral Features #####
27 ================================================================================
28 [..] The device integrates up to 3 operational amplifiers OPAMP1, OPAMP2,
29 OPAMP3 (OPAMP3 availability depends on device category)
30
31 (#) The OPAMP(s) provide(s) several exclusive running modes.
32 (++) Standalone mode
33 (++) Follower mode
34
35 (#) All OPAMP (same for all OPAMPs) can operate in
36 (++) Either Low range (VDDA < 2.4V) power supply
37 (++) Or High range (VDDA > 2.4V) power supply
38
39 (#) Each OPAMP(s) can be configured in normal and low power mode.
40
41 (#) The OPAMP(s) provide(s) calibration capabilities.
42 (++) Calibration aims at correcting some offset for running mode.
43 (++) The OPAMP uses either factory calibration settings OR user defined
44 calibration (trimming) settings (i.e. trimming mode).
45 (++) The user defined settings can be figured out using self calibration
46 handled by HAL_OPAMP_SelfCalibrate, HAL_OPAMPEx_SelfCalibrateAll
47 (++) HAL_OPAMP_SelfCalibrate:
48 (+++) Runs automatically the calibration in 2 steps: for transistors
49 differential pair high (PMOS) or low (NMOS)
50 (+++) Enables the user trimming mode
51 (+++) Updates the init structure with trimming values with fresh calibration
52 results.
53 The user may store the calibration results for larger
54 (ex monitoring the trimming as a function of temperature
55 for instance)
56 (+++) For devices having several OPAMPs, HAL_OPAMPEx_SelfCalibrateAll
57 runs calibration of all OPAMPs in parallel to save search time.
58
59 (#) Running mode: Standalone mode
60 (++) Gain is set externally (gain depends on external loads).
61 (++) Follower mode also possible externally by connecting the inverting input to
62 the output.
63
64 (#) Running mode: Follower mode
65 (++) No Inverting Input is connected.
66 (++) The OPAMP(s) output(s) are internally connected to inverting input.
67
68 ##### How to use this driver #####
69 ================================================================================
70 [..]
71
72 *** Power supply range ***
73 ============================================
74 [..] To run in low power mode:
75
76 (#) Configure the OPAMP using HAL_OPAMP_Init() function:
77 (++) Select OPAMP_POWERSUPPLY_LOW (VDDA lower than 2.4V)
78 (++) Otherwise select OPAMP_POWERSUPPLY_HIGH (VDDA higher than 2.4V)
79
80 *** Low / normal power mode ***
81 ============================================
82 [..] To run in low power mode:
83
84 (#) Configure the OPAMP using HAL_OPAMP_Init() function:
85 (++) Select OPAMP_POWERMODE_LOWPOWER
86 (++) Otherwise select OPAMP_POWERMODE_NORMAL
87
88 *** Calibration ***
89 ============================================
90 [..] To run the OPAMP calibration self calibration:
91
92 (#) Start calibration using HAL_OPAMP_SelfCalibrate.
93 Store the calibration results.
94
95 *** Running mode ***
96 ============================================
97
98 [..] To use the OPAMP, perform the following steps:
99
100 (#) Fill in the HAL_OPAMP_MspInit() to
101 (++) Enable the OPAMP Peripheral clock using macro __HAL_RCC_OPAMP_CLK_ENABLE()
102 (++) Configure the OPAMP input AND output in analog mode using
103 HAL_GPIO_Init() to map the OPAMP output to the GPIO pin.
104
105 (#) Registrate Callbacks
106 (++) The compilation define USE_HAL_OPAMP_REGISTER_CALLBACKS when set to 1
107 allows the user to configure dynamically the driver callbacks.
108
109 (++) Use Functions HAL_OPAMP_RegisterCallback() to register a user callback,
110 it allows to register following callbacks:
111 (+++) MspInitCallback : OPAMP MspInit.
112 (+++) MspDeInitCallback : OPAMP MspFeInit.
113 This function takes as parameters the HAL peripheral handle, the Callback ID
114 and a pointer to the user callback function.
115
116 (++) Use function HAL_OPAMP_UnRegisterCallback() to reset a callback to the default
117 weak (overridden) function. It allows to reset following callbacks:
118 (+++) MspInitCallback : OPAMP MspInit.
119 (+++) MspDeInitCallback : OPAMP MspdeInit.
120 (+++) All Callbacks
121
122 (#) Configure the OPAMP using HAL_OPAMP_Init() function:
123 (++) Select the mode
124 (++) Select the inverting input
125 (++) Select the non-inverting input
126 (++) Select either factory or user defined trimming mode.
127 (++) If the user-defined trimming mode is enabled, select PMOS & NMOS trimming values
128 (typically values set by HAL_OPAMP_SelfCalibrate function).
129
130 (#) Enable the OPAMP using HAL_OPAMP_Start() function.
131
132 (#) Disable the OPAMP using HAL_OPAMP_Stop() function.
133
134 (#) Lock the OPAMP in running mode using HAL_OPAMP_Lock() function.
135 Caution: On STM32L1, HAL OPAMP lock is software lock only (not
136 hardware lock as on some other STM32 devices)
137
138 (#) If needed, unlock the OPAMP using HAL_OPAMPEx_Unlock() function.
139
140 *** Running mode: change of configuration while OPAMP ON ***
141 ============================================
142 [..] To Re-configure OPAMP when OPAMP is ON (change on the fly)
143 (#) If needed, fill in the HAL_OPAMP_MspInit()
144 (++) This is the case for instance if you wish to use new OPAMP I/O
145
146 (#) Configure the OPAMP using HAL_OPAMP_Init() function:
147 (++) As in configure case, select first the parameters you wish to modify.
148
149 (#) Change from low power mode to normal power mode (& vice versa) requires
150 first HAL_OPAMP_DeInit() (force OPAMP OFF) and then HAL_OPAMP_Init().
151 In other words, of OPAMP is ON, HAL_OPAMP_Init can NOT change power mode
152 alone.
153
154 @endverbatim
155 ******************************************************************************
156 */
157
158 /*
159 Additional remark:
160 The OPAMPs inverting input can be selected among the list shown by table below.
161 The OPAMPs non inverting input can be selected among the list shown by table below.
162
163 Table 1. OPAMPs inverting/non-inverting inputs for STM32L1 devices:
164 +--------------------------------------------------------------------------+
165 | | HAL param | OPAMP1 | OPAMP2 | OPAMP3(4) |
166 | | name | | | |
167 |----------------|------------|--------------|--------------|--------------|
168 | Inverting | VM0 | PA2 | PA7 | PC2 |
169 | input (1) | VM1 | VINM pin (2) | VINM pin (2) | VINM pin (2) |
170 |----------------|------------|--------------|--------------|--------------|
171 | Non Inverting | VP0 | PA1 | PA6 | PC1 |
172 | input | DAC_CH1 (3)| DAC_CH1 | DAC_CH1 | --- |
173 | | DAC_CH2 (3)| --- | DAC_CH2 | DAC_CH2 |
174 +--------------------------------------------------------------------------+
175 (1): NA in follower mode.
176 (2): OPAMP input OPAMPx_VINM are dedicated OPAMP pins, their availability
177 depends on device package.
178 (3): DAC channels 1 and 2 are connected internally to OPAMP. Nevertheless,
179 I/O pins connected to DAC can still be used as DAC output (pins PA4
180 and PA5).
181 (4): OPAMP3 availability depends on device category.
182
183 Table 2. OPAMPs outputs for STM32L1 devices:
184 +--------------------------------------------------------+
185 | | OPAMP1 | OPAMP2 | OPAMP3(4) |
186 |-----------------|------------|------------|------------|
187 | Output | PA3 | PB0 | PC3 |
188 +--------------------------------------------------------+
189 (4) : OPAMP3 availability depends on device category
190 */
191
192 /* Includes ------------------------------------------------------------------*/
193 #include "stm32l1xx_hal.h"
194
195 /** @addtogroup STM32L1xx_HAL_Driver
196 * @{
197 */
198
199 /** @defgroup OPAMP OPAMP
200 * @brief OPAMP module driver
201 * @{
202 */
203
204 #ifdef HAL_OPAMP_MODULE_ENABLED
205
206 #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)
207
208 /* Private typedef -----------------------------------------------------------*/
209 /* Private define ------------------------------------------------------------*/
210 /* Private macro -------------------------------------------------------------*/
211 /* Private variables ---------------------------------------------------------*/
212 /* Private constants ---------------------------------------------------------*/
213 /* Private function prototypes -----------------------------------------------*/
214 /* Private functions ---------------------------------------------------------*/
215 /* Exported functions --------------------------------------------------------*/
216
217 /** @defgroup OPAMP_Exported_Functions OPAMP Exported Functions
218 * @{
219 */
220
221 /** @defgroup OPAMP_Exported_Functions_Group1 Initialization and de-initialization functions
222 * @brief Initialization and Configuration functions
223 *
224 @verbatim
225 ==============================================================================
226 ##### Initialization and de-initialization functions #####
227 ==============================================================================
228 [..] This section provides functions allowing to:
229
230 @endverbatim
231 * @{
232 */
233
234 /**
235 * @brief Initializes the OPAMP according to the specified
236 * parameters in the OPAMP_InitTypeDef and create the associated handle.
237 * @note If the selected opamp is locked, initialization can't be performed.
238 * To unlock the configuration, perform a system reset.
239 * @param hopamp OPAMP handle
240 * @retval HAL status
241 */
HAL_OPAMP_Init(OPAMP_HandleTypeDef * hopamp)242 HAL_StatusTypeDef HAL_OPAMP_Init(OPAMP_HandleTypeDef* hopamp)
243 {
244 HAL_StatusTypeDef status = HAL_OK;
245 uint32_t tmp_csr; /* Temporary variable to update register CSR, except bits ANAWSSELx, S7SEL2, OPA_RANGE, OPAxCALOUT */
246
247 /* Check the OPAMP handle allocation and lock status */
248 /* Init not allowed if calibration is ongoing */
249 if(hopamp == NULL)
250 {
251 return HAL_ERROR;
252 }
253 else if(hopamp->State == HAL_OPAMP_STATE_BUSYLOCKED)
254 {
255 return HAL_ERROR;
256 }
257 else if(hopamp->State == HAL_OPAMP_STATE_CALIBBUSY)
258 {
259 return HAL_ERROR;
260 }
261 else
262 {
263 /* Check the parameter */
264 assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
265
266 /* Set OPAMP parameters */
267 assert_param(IS_OPAMP_POWER_SUPPLY_RANGE(hopamp->Init.PowerSupplyRange));
268 assert_param(IS_OPAMP_POWERMODE(hopamp->Init.PowerMode));
269 assert_param(IS_OPAMP_FUNCTIONAL_NORMALMODE(hopamp->Init.Mode));
270 assert_param(IS_OPAMP_NONINVERTING_INPUT_CHECK_INSTANCE(hopamp, hopamp->Init.NonInvertingInput));
271 assert_param(IS_OPAMP_TRIMMING(hopamp->Init.UserTrimming));
272
273 #if (USE_HAL_OPAMP_REGISTER_CALLBACKS == 1)
274 if(hopamp->State == HAL_OPAMP_STATE_RESET)
275 {
276 if(hopamp->MspInitCallback == NULL)
277 {
278 hopamp->MspInitCallback = HAL_OPAMP_MspInit;
279 }
280 }
281 #endif /* USE_HAL_OPAMP_REGISTER_CALLBACKS */
282
283 if (hopamp->Init.Mode != OPAMP_FOLLOWER_MODE)
284 {
285 assert_param(IS_OPAMP_INVERTING_INPUT(hopamp->Init.InvertingInput));
286 }
287
288 if (hopamp->Init.UserTrimming == OPAMP_TRIMMING_USER)
289 {
290 if (hopamp->Init.PowerMode == OPAMP_POWERMODE_NORMAL)
291 {
292 assert_param(IS_OPAMP_TRIMMINGVALUE(hopamp->Init.TrimmingValueP));
293 assert_param(IS_OPAMP_TRIMMINGVALUE(hopamp->Init.TrimmingValueN));
294 }
295 else
296 {
297 assert_param(IS_OPAMP_TRIMMINGVALUE(hopamp->Init.TrimmingValuePLowPower));
298 assert_param(IS_OPAMP_TRIMMINGVALUE(hopamp->Init.TrimmingValueNLowPower));
299 }
300 }
301
302 if(hopamp->State == HAL_OPAMP_STATE_RESET)
303 {
304 /* Allocate lock resource and initialize it */
305 hopamp->Lock = HAL_UNLOCKED;
306 }
307
308 #if (USE_HAL_OPAMP_REGISTER_CALLBACKS == 1)
309 hopamp->MspInitCallback(hopamp);
310 #else
311 /* Call MSP init function */
312 HAL_OPAMP_MspInit(hopamp);
313 #endif /* USE_HAL_OPAMP_REGISTER_CALLBACKS */
314
315 /* Set OPAMP parameters */
316 /* - Set internal switches in function of: */
317 /* - OPAMP selected mode: standalone or follower. */
318 /* - Non-inverting input connection */
319 /* - Inverting input connection */
320 /* - Set power supply range */
321 /* - Set power mode and associated calibration parameters */
322
323 /* Get OPAMP CSR register into temporary variable */
324 /* Note: OPAMP register CSR is written directly, independently of OPAMP */
325 /* instance, because all OPAMP settings are dispatched in the same */
326 /* register. */
327 /* Settings of bits for each OPAMP instances are managed case by */
328 /* case using macro (OPAMP_CSR_S3SELX(), OPAMP_CSR_ANAWSELX(), ...) */
329 tmp_csr = OPAMP->CSR;
330
331 /* Open all switches on non-inverting input, inverting input and output */
332 /* feedback. */
333 CLEAR_BIT(tmp_csr, OPAMP_CSR_ALL_SWITCHES(hopamp));
334
335 /* Set internal switches in function of OPAMP mode selected: standalone */
336 /* or follower. */
337 /* If follower mode is selected, feedback switch S3 is closed and */
338 /* inverting inputs switches are let opened. */
339 /* If standalone mode is selected, feedback switch S3 is let opened and */
340 /* the selected inverting inputs switch is closed. */
341 if (hopamp->Init.Mode == OPAMP_FOLLOWER_MODE)
342 {
343 /* Follower mode: Close switches S3 and SanB */
344 SET_BIT(tmp_csr, OPAMP_CSR_S3SELX(hopamp));
345 }
346 else
347 {
348 /* Set internal switches in function of inverting input selected: */
349 /* Close switch to connect OPAMP inverting input to the selected */
350 /* input: dedicated IO pin or alternative IO pin available on some */
351 /* device packages. */
352 if (hopamp->Init.InvertingInput == OPAMP_INVERTINGINPUT_IO0)
353 {
354 /* Close switch to connect OPAMP non-inverting input to */
355 /* dedicated IO pin low-leakage. */
356 SET_BIT(tmp_csr, OPAMP_CSR_S4SELX(hopamp));
357 }
358 else
359 {
360 /* Close switch to connect OPAMP inverting input to alternative */
361 /* IO pin available on some device packages. */
362 SET_BIT(tmp_csr, OPAMP_CSR_ANAWSELX(hopamp));
363 }
364 }
365
366 /* Set internal switches in function of non-inverting input selected: */
367 /* Close switch to connect OPAMP non-inverting input to the selected */
368 /* input: dedicated IO pin or DAC channel. */
369 if (hopamp->Init.NonInvertingInput == OPAMP_NONINVERTINGINPUT_IO0)
370 {
371 /* Close switch to connect OPAMP non-inverting input to */
372 /* dedicated IO pin low-leakage. */
373 SET_BIT(tmp_csr, OPAMP_CSR_S5SELX(hopamp));
374 }
375 else if (hopamp->Init.NonInvertingInput == OPAMP_NONINVERTINGINPUT_DAC_CH1)
376 {
377
378 /* Particular case for connection to DAC channel 1: */
379 /* OPAMP_NONINVERTINGINPUT_DAC_CH1 available on OPAMP1 and OPAMP2 only */
380 /* (OPAMP3 availability depends on device category). */
381 if ((hopamp->Instance == OPAMP1) || (hopamp->Instance == OPAMP2))
382 {
383 /* Close switch to connect OPAMP non-inverting input to */
384 /* DAC channel 1. */
385 SET_BIT(tmp_csr, OPAMP_CSR_S6SELX(hopamp));
386 }
387 else
388 {
389 /* Set HAL status to error if another OPAMP instance as OPAMP1 or */
390 /* OPAMP2 is intended to be connected to DAC channel 2. */
391 status = HAL_ERROR;
392 }
393 }
394 else /* if (hopamp->Init.NonInvertingInput == */
395 /* OPAMP_NONINVERTINGINPUT_DAC_CH2 ) */
396 {
397 /* Particular case for connection to DAC channel 2: */
398 /* OPAMP_NONINVERTINGINPUT_DAC_CH2 available on OPAMP2 and OPAMP3 only */
399 /* (OPAMP3 availability depends on device category). */
400 if (hopamp->Instance == OPAMP2)
401 {
402 /* Close switch to connect OPAMP non-inverting input to */
403 /* DAC channel 2. */
404 SET_BIT(tmp_csr, OPAMP_CSR_S7SEL2);
405 }
406 /* If OPAMP3 is selected (if available) */
407 else if (hopamp->Instance != OPAMP1)
408 {
409 /* Close switch to connect OPAMP non-inverting input to */
410 /* DAC channel 2. */
411 SET_BIT(tmp_csr, OPAMP_CSR_S6SELX(hopamp));
412 }
413 else
414 {
415 /* Set HAL status to error if another OPAMP instance as OPAMP2 or */
416 /* OPAMP3 (if available) is intended to be connected to DAC channel 2.*/
417 status = HAL_ERROR;
418 }
419 }
420
421 /* Continue OPAMP configuration if settings of switches are correct */
422 if (status != HAL_ERROR)
423 {
424 /* Set power mode and associated calibration parameters */
425 if (hopamp->Init.PowerMode != OPAMP_POWERMODE_LOWPOWER)
426 {
427 /* Set normal mode */
428 CLEAR_BIT(tmp_csr, OPAMP_CSR_OPAXLPM(hopamp));
429
430 if (hopamp->Init.UserTrimming == OPAMP_TRIMMING_USER)
431 {
432 /* Set calibration mode (factory or user) and values for */
433 /* transistors differential pair high (PMOS) and low (NMOS) for */
434 /* normal mode. */
435 MODIFY_REG(OPAMP->OTR, OPAMP_OTR_OT_USER |
436 OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_N, OPAMP_TRIM_VALUE_MASK) |
437 OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_P, OPAMP_TRIM_VALUE_MASK) ,
438 hopamp->Init.UserTrimming |
439 OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_N, hopamp->Init.TrimmingValueN) |
440 OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_P, hopamp->Init.TrimmingValueP) );
441 }
442 else
443 {
444 /* Set calibration mode to factory */
445 CLEAR_BIT(OPAMP->OTR, OPAMP_OTR_OT_USER);
446 }
447
448 }
449 else
450 {
451 /* Set low power mode */
452 SET_BIT(tmp_csr, OPAMP_CSR_OPAXLPM(hopamp));
453
454 if (hopamp->Init.UserTrimming == OPAMP_TRIMMING_USER)
455 {
456 /* Set calibration mode to user trimming */
457 SET_BIT(OPAMP->OTR, OPAMP_OTR_OT_USER);
458
459 /* Set values for transistors differential pair high (PMOS) and low */
460 /* (NMOS) for low power mode. */
461 MODIFY_REG(OPAMP->LPOTR, OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_N, OPAMP_TRIM_VALUE_MASK) |
462 OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_P, OPAMP_TRIM_VALUE_MASK) ,
463 OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_N, hopamp->Init.TrimmingValueNLowPower) |
464 OPAMP_OFFSET_TRIM_SET(hopamp, OPAMP_FACTORYTRIMMING_P, hopamp->Init.TrimmingValuePLowPower) );
465 }
466 else
467 {
468 /* Set calibration mode to factory trimming */
469 CLEAR_BIT(OPAMP->OTR, OPAMP_OTR_OT_USER);
470 }
471
472 }
473
474
475 /* Configure the power supply range */
476 MODIFY_REG(tmp_csr, OPAMP_CSR_AOP_RANGE,
477 hopamp->Init.PowerSupplyRange);
478
479 /* Set OPAMP CSR register from temporary variable */
480 /* This allows to apply all changes on one time, in case of update on */
481 /* the fly with OPAMP previously set and running: */
482 /* - to avoid hazardous transient switches settings (risk of short */
483 /* circuit) */
484 /* - to avoid interruption of input signal */
485 OPAMP->CSR = tmp_csr;
486
487
488 /* Update the OPAMP state */
489 /* If coming from state reset: Update from state RESET to state READY */
490 if (hopamp->State == HAL_OPAMP_STATE_RESET)
491 {
492 hopamp->State = HAL_OPAMP_STATE_READY;
493 }
494 /* else: OPAMP state remains READY or BUSY state (no update) */
495 }
496 }
497
498 return status;
499 }
500
501 /**
502 * @brief DeInitializes the OPAMP peripheral
503 * @note Deinitialization can be performed if the OPAMP configuration is locked.
504 * (the OPAMP lock is SW in STM32L1)
505 * @param hopamp OPAMP handle
506 * @retval HAL status
507 */
HAL_OPAMP_DeInit(OPAMP_HandleTypeDef * hopamp)508 HAL_StatusTypeDef HAL_OPAMP_DeInit(OPAMP_HandleTypeDef* hopamp)
509 {
510 HAL_StatusTypeDef status = HAL_OK;
511
512 /* Check the OPAMP handle allocation */
513 /* DeInit not allowed if calibration is ongoing */
514 if(hopamp == NULL)
515 {
516 status = HAL_ERROR;
517 }
518 else if(hopamp->State == HAL_OPAMP_STATE_CALIBBUSY)
519 {
520 status = HAL_ERROR;
521 }
522 else
523 {
524 /* Check the parameter */
525 assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
526
527 /* Disable the selected opamp */
528 SET_BIT (OPAMP->CSR, OPAMP_CSR_OPAXPD(hopamp));
529
530 /* Open all switches on non-inverting input, inverting input and output */
531 /* feedback. */
532 /* Note: OPAMP register CSR is written directly, independently of OPAMP */
533 /* instance, because all OPAMP settings are dispatched in the same */
534 /* register. */
535 /* Settings of bits for each OPAMP instances are managed case by */
536 /* case using macro (OPAMP_CSR_S3SELX(), OPAMP_CSR_ANAWSELX(), ...) */
537 CLEAR_BIT(OPAMP->CSR, OPAMP_CSR_ALL_SWITCHES(hopamp));
538
539 /* Note: Registers and bits shared with other OPAMP instances are kept */
540 /* unchanged, to not impact other OPAMP while operating on the */
541 /* selected OPAMP. */
542 /* Unchanged: bit OPAMP_OTR_OT_USER (parameter "UserTrimming") */
543 /* bit OPAMP_CSR_AOP_RANGE (parameter "PowerSupplyRange")*/
544
545 #if (USE_HAL_OPAMP_REGISTER_CALLBACKS == 1)
546 if(hopamp->MspDeInitCallback == NULL)
547 {
548 hopamp->MspDeInitCallback = HAL_OPAMP_MspDeInit;
549 }
550 /* DeInit the low level hardware */
551 hopamp->MspDeInitCallback(hopamp);
552 #else
553 /* DeInit the low level hardware: GPIO, CLOCK and NVIC */
554 HAL_OPAMP_MspDeInit(hopamp);
555 #endif /* USE_HAL_OPAMP_REGISTER_CALLBACKS */
556
557 /* Update the OPAMP state*/
558 hopamp->State = HAL_OPAMP_STATE_RESET;
559 }
560
561 /* Process unlocked */
562 __HAL_UNLOCK(hopamp);
563
564 return status;
565 }
566
567 /**
568 * @brief Initialize the OPAMP MSP.
569 * @param hopamp OPAMP handle
570 * @retval None
571 */
HAL_OPAMP_MspInit(OPAMP_HandleTypeDef * hopamp)572 __weak void HAL_OPAMP_MspInit(OPAMP_HandleTypeDef* hopamp)
573 {
574 /* Prevent unused argument(s) compilation warning */
575 UNUSED(hopamp);
576
577 /* NOTE : This function should not be modified, when the callback is needed,
578 the function "HAL_OPAMP_MspInit()" must be implemented in the user file.
579 */
580 }
581
582 /**
583 * @brief DeInitialize OPAMP MSP.
584 * @param hopamp OPAMP handle
585 * @retval None
586 */
HAL_OPAMP_MspDeInit(OPAMP_HandleTypeDef * hopamp)587 __weak void HAL_OPAMP_MspDeInit(OPAMP_HandleTypeDef* hopamp)
588 {
589 /* Prevent unused argument(s) compilation warning */
590 UNUSED(hopamp);
591
592 /* NOTE : This function should not be modified, when the callback is needed,
593 the function "HAL_OPAMP_MspDeInit()" must be implemented in the user file.
594 */
595 }
596
597 /**
598 * @}
599 */
600
601
602 /** @defgroup OPAMP_Exported_Functions_Group2 IO operation functions
603 * @brief IO operation functions
604 *
605 @verbatim
606 ===============================================================================
607 ##### IO operation functions #####
608 ===============================================================================
609 [..]
610 This subsection provides a set of functions allowing to manage the OPAMP
611 start, stop and calibration actions.
612
613 @endverbatim
614 * @{
615 */
616
617 /**
618 * @brief Start the OPAMP.
619 * @param hopamp OPAMP handle
620 * @retval HAL status
621 */
622
HAL_OPAMP_Start(OPAMP_HandleTypeDef * hopamp)623 HAL_StatusTypeDef HAL_OPAMP_Start(OPAMP_HandleTypeDef* hopamp)
624 {
625 HAL_StatusTypeDef status = HAL_OK;
626
627 /* Check the OPAMP handle allocation */
628 /* Check if OPAMP locked */
629 if(hopamp == NULL)
630 {
631 status = HAL_ERROR;
632 }
633 else if(hopamp->State == HAL_OPAMP_STATE_BUSYLOCKED)
634 {
635 status = HAL_ERROR;
636 }
637 else
638 {
639 /* Check the parameter */
640 assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
641
642 if(hopamp->State == HAL_OPAMP_STATE_READY)
643 {
644 /* Enable the selected opamp */
645 CLEAR_BIT (OPAMP->CSR, OPAMP_CSR_OPAXPD(hopamp));
646
647 /* Update the OPAMP state */
648 /* From HAL_OPAMP_STATE_READY to HAL_OPAMP_STATE_BUSY */
649 hopamp->State = HAL_OPAMP_STATE_BUSY;
650 }
651 else
652 {
653 status = HAL_ERROR;
654 }
655
656 }
657 return status;
658 }
659
660 /**
661 * @brief Stop the OPAMP.
662 * @param hopamp OPAMP handle
663 * @retval HAL status
664 */
HAL_OPAMP_Stop(OPAMP_HandleTypeDef * hopamp)665 HAL_StatusTypeDef HAL_OPAMP_Stop(OPAMP_HandleTypeDef* hopamp)
666 {
667 HAL_StatusTypeDef status = HAL_OK;
668
669 /* Check the OPAMP handle allocation */
670 /* Check if OPAMP locked */
671 /* Check if OPAMP calibration ongoing */
672 if(hopamp == NULL)
673 {
674 status = HAL_ERROR;
675 }
676 else if(hopamp->State == HAL_OPAMP_STATE_BUSYLOCKED)
677 {
678 status = HAL_ERROR;
679 }
680 else if(hopamp->State == HAL_OPAMP_STATE_CALIBBUSY)
681 {
682 status = HAL_ERROR;
683 }
684 else
685 {
686 /* Check the parameter */
687 assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
688
689 if(hopamp->State == HAL_OPAMP_STATE_BUSY)
690 {
691 /* Disable the selected opamp */
692 SET_BIT (OPAMP->CSR, OPAMP_CSR_OPAXPD(hopamp));
693
694 /* Update the OPAMP state*/
695 /* From HAL_OPAMP_STATE_BUSY to HAL_OPAMP_STATE_READY*/
696 hopamp->State = HAL_OPAMP_STATE_READY;
697 }
698 else
699 {
700 status = HAL_ERROR;
701 }
702 }
703 return status;
704 }
705
706 /**
707 * @brief Run the self calibration of one OPAMP.
708 * @note Trimming values (PMOS & NMOS) are updated and user trimming is
709 * enabled if calibration is successful.
710 * @note Calibration is performed in the mode specified in OPAMP init
711 * structure (mode normal or low-power). To perform calibration for
712 * both modes, repeat this function twice after OPAMP init structure
713 * accordingly updated.
714 * @note Calibration runs about 10 ms.
715 * @param hopamp handle
716 * @retval Updated offset trimming values (PMOS & NMOS), user trimming is enabled
717 * @retval HAL status
718 */
HAL_OPAMP_SelfCalibrate(OPAMP_HandleTypeDef * hopamp)719 HAL_StatusTypeDef HAL_OPAMP_SelfCalibrate(OPAMP_HandleTypeDef* hopamp)
720 {
721 HAL_StatusTypeDef status = HAL_OK;
722
723 uint32_t* opamp_trimmingvalue;
724 uint32_t opamp_trimmingvaluen = 0;
725 uint32_t opamp_trimmingvaluep = 0;
726
727 uint32_t trimming_diff_pair; /* Selection of differential transistors pair high or low */
728
729 __IO uint32_t* tmp_opamp_reg_trimming; /* Selection of register of trimming depending on power mode: OTR or LPOTR */
730 uint32_t tmp_opamp_otr_otuser; /* Selection of bit OPAMP_OTR_OT_USER depending on trimming register pointed: OTR or LPOTR */
731
732 uint32_t tmp_Opaxcalout_DefaultSate; /* Bit OPAMP_CSR_OPAXCALOUT default state when trimming value is 00000b. Used to detect the bit toggling */
733
734 uint32_t tmp_OpaxSwitchesContextBackup;
735
736 uint8_t trimming_diff_pair_iteration_count; /* For calibration loop algorithm: to repeat the calibration loop for both differential transistors pair high and low */
737 uint8_t delta; /* For calibration loop algorithm: Variable for dichotomy steps value */
738 uint8_t final_step_check = 0x0U; /* For calibration loop algorithm: Flag for additional check of last trimming step */
739
740 /* Check the OPAMP handle allocation */
741 /* Check if OPAMP locked */
742 if(hopamp == NULL)
743 {
744 status = HAL_ERROR;
745 }
746 else if(hopamp->State == HAL_OPAMP_STATE_BUSYLOCKED)
747 {
748 status = HAL_ERROR;
749 }
750 else
751 {
752
753 /* Check if OPAMP in calibration mode and calibration not yet enable */
754 if(hopamp->State == HAL_OPAMP_STATE_READY)
755 {
756 /* Check the parameter */
757 assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
758 assert_param(IS_OPAMP_POWERMODE(hopamp->Init.PowerMode));
759
760 /* Update OPAMP state */
761 hopamp->State = HAL_OPAMP_STATE_CALIBBUSY;
762
763 /* Backup of switches configuration to restore it at the end of the */
764 /* calibration. */
765 tmp_OpaxSwitchesContextBackup = READ_BIT(OPAMP->CSR, OPAMP_CSR_ALL_SWITCHES(hopamp));
766
767 /* Open all switches on non-inverting input, inverting input and output */
768 /* feedback. */
769 CLEAR_BIT(OPAMP->CSR, OPAMP_CSR_ALL_SWITCHES(hopamp));
770
771 /* Set calibration mode to user programmed trimming values */
772 SET_BIT(OPAMP->OTR, OPAMP_OTR_OT_USER);
773
774
775 /* Select trimming settings depending on power mode */
776 if (hopamp->Init.PowerMode == OPAMP_POWERMODE_NORMAL)
777 {
778 tmp_opamp_otr_otuser = OPAMP_OTR_OT_USER;
779 tmp_opamp_reg_trimming = &OPAMP->OTR;
780 }
781 else
782 {
783 tmp_opamp_otr_otuser = 0x00000000U;
784 tmp_opamp_reg_trimming = &OPAMP->LPOTR;
785 }
786
787
788 /* Enable the selected opamp */
789 CLEAR_BIT (OPAMP->CSR, OPAMP_CSR_OPAXPD(hopamp));
790
791 /* Perform trimming for both differential transistors pair high and low */
792 for (trimming_diff_pair_iteration_count = 0U; trimming_diff_pair_iteration_count <=1U; trimming_diff_pair_iteration_count++)
793 {
794 if (trimming_diff_pair_iteration_count == 0U)
795 {
796 /* Calibration of transistors differential pair high (NMOS) */
797 trimming_diff_pair = OPAMP_FACTORYTRIMMING_N;
798 opamp_trimmingvalue = &opamp_trimmingvaluen;
799
800 /* Set bit OPAMP_CSR_OPAXCALOUT default state when trimming value */
801 /* is 00000b. Used to detect the bit toggling during trimming. */
802 tmp_Opaxcalout_DefaultSate = 0U;
803
804 /* Enable calibration for N differential pair */
805 MODIFY_REG(OPAMP->CSR, OPAMP_CSR_OPAXCAL_L(hopamp),
806 OPAMP_CSR_OPAXCAL_H(hopamp) );
807 }
808 else /* (trimming_diff_pair_iteration_count == 1) */
809 {
810 /* Calibration of transistors differential pair low (PMOS) */
811 trimming_diff_pair = OPAMP_FACTORYTRIMMING_P;
812 opamp_trimmingvalue = &opamp_trimmingvaluep;
813
814 /* Set bit OPAMP_CSR_OPAXCALOUT default state when trimming value */
815 /* is 00000b. Used to detect the bit toggling during trimming. */
816 tmp_Opaxcalout_DefaultSate = OPAMP_CSR_OPAXCALOUT(hopamp);
817
818 /* Enable calibration for P differential pair */
819 MODIFY_REG(OPAMP->CSR, OPAMP_CSR_OPAXCAL_H(hopamp),
820 OPAMP_CSR_OPAXCAL_L(hopamp) );
821 }
822
823
824 /* Perform calibration parameter search by dichotomy sweep */
825 /* - Delta initial value 16: for 5 dichotomy steps: 16 for the */
826 /* initial range, then successive delta sweeps (8, 4, 2, 1). */
827 /* can extend the search range to +/- 15 units. */
828 /* - Trimming initial value 15: search range will go from 0 to 30 */
829 /* (Trimming value 31 is forbidden). */
830 /* Note: After dichotomy sweep, the trimming result is determined. */
831 /* However, the final trimming step is deduced from previous */
832 /* trimming steps tested but is not effectively tested. */
833 /* An additional test step (using variable "final_step_check") */
834 /* allow to Test the final trimming step. */
835 *opamp_trimmingvalue = 15U;
836 delta = 16U;
837
838 while ((delta != 0U) || (final_step_check == 1U))
839 {
840 /* Set candidate trimming */
841 MODIFY_REG(*tmp_opamp_reg_trimming, OPAMP_OFFSET_TRIM_SET(hopamp, trimming_diff_pair, OPAMP_TRIM_VALUE_MASK) ,
842 OPAMP_OFFSET_TRIM_SET(hopamp, trimming_diff_pair, *opamp_trimmingvalue) | tmp_opamp_otr_otuser);
843
844 /* Offset trimming time: during calibration, minimum time needed */
845 /* between two steps to have 1 mV accuracy. */
846 HAL_Delay(OPAMP_TRIMMING_DELAY);
847
848 /* Set flag for additional check of last trimming step equal to */
849 /* dichotomy step before its division by 2 (equivalent to previous */
850 /* value of dichotomy step). */
851 final_step_check = delta;
852
853 /* Divide range by 2 to continue dichotomy sweep */
854 delta >>= 1;
855
856 /* Set trimming values for next iteration in function of trimming */
857 /* result toggle (versus initial state). */
858 /* Note: on the last trimming loop, delta is equal to 0 and */
859 /* therefore has no effect. */
860 if (READ_BIT(OPAMP->CSR, OPAMP_CSR_OPAXCALOUT(hopamp)) != tmp_Opaxcalout_DefaultSate)
861 {
862 /* If calibration output is has toggled, try lower trimming */
863 *opamp_trimmingvalue -= delta;
864 }
865 else
866 {
867 /* If calibration output is has not toggled, try higher trimming */
868 *opamp_trimmingvalue += delta;
869 }
870
871 }
872
873 /* Check trimming result of the selected step and perform final fine */
874 /* trimming. */
875 /* - If calibration output is has toggled: the current step is */
876 /* already optimized. */
877 /* - If calibration output is has not toggled: the current step can */
878 /* be optimized by incrementing it of one step. */
879 if (READ_BIT(OPAMP->CSR, OPAMP_CSR_OPAXCALOUT(hopamp)) == tmp_Opaxcalout_DefaultSate)
880 {
881 *opamp_trimmingvalue += 1U;
882
883 /* Set final fine trimming */
884 MODIFY_REG(*tmp_opamp_reg_trimming, OPAMP_OFFSET_TRIM_SET(hopamp, trimming_diff_pair, OPAMP_TRIM_VALUE_MASK) ,
885 OPAMP_OFFSET_TRIM_SET(hopamp, trimming_diff_pair, *opamp_trimmingvalue) | tmp_opamp_otr_otuser);
886 }
887
888 }
889
890
891 /* Disable calibration for P and N differential pairs */
892 /* Disable the selected opamp */
893 CLEAR_BIT (OPAMP->CSR, (OPAMP_CSR_OPAXCAL_H(hopamp) |
894 OPAMP_CSR_OPAXCAL_L(hopamp) |
895 OPAMP_CSR_OPAXPD(hopamp)) );
896
897 /* Backup of switches configuration to restore it at the end of the */
898 /* calibration. */
899 SET_BIT(OPAMP->CSR, tmp_OpaxSwitchesContextBackup);
900
901 /* Self calibration is successful */
902 /* Store calibration (user trimming) results in init structure. */
903
904 /* Set user trimming mode */
905 hopamp->Init.UserTrimming = OPAMP_TRIMMING_USER;
906
907 /* Check on unsupported value */
908 if(opamp_trimmingvaluep == 0x1FU) /* 0x1F is not functional */
909 {
910 opamp_trimmingvaluep = 30U;
911 }
912
913 if(opamp_trimmingvaluen == 0x1FU) /* 0x1F is not functional */
914 {
915 opamp_trimmingvaluen = 30U;
916 }
917
918 /* Affect calibration parameters depending on mode normal/low power */
919 if (hopamp->Init.PowerMode != OPAMP_POWERMODE_LOWPOWER)
920 {
921 /* Write calibration result N */
922 hopamp->Init.TrimmingValueN = opamp_trimmingvaluen;
923 /* Write calibration result P */
924 hopamp->Init.TrimmingValueP = opamp_trimmingvaluep;
925 }
926 else
927 {
928 /* Write calibration result N */
929 hopamp->Init.TrimmingValueNLowPower = opamp_trimmingvaluen;
930 /* Write calibration result P */
931 hopamp->Init.TrimmingValuePLowPower = opamp_trimmingvaluep;
932 }
933
934 /* Update OPAMP state */
935 hopamp->State = HAL_OPAMP_STATE_READY;
936
937 }
938
939 else
940 {
941 /* OPAMP can not be calibrated from this mode */
942 status = HAL_ERROR;
943 }
944 }
945
946 return status;
947
948 }
949
950 /**
951 * @}
952 */
953
954 /**
955 * @}
956 */
957
958 /** @defgroup OPAMP_Exported_Functions_Group3 Peripheral Control functions
959 * @brief Peripheral Control functions
960 *
961 @verbatim
962 ===============================================================================
963 ##### Peripheral Control functions #####
964 ===============================================================================
965 [..]
966 This subsection provides a set of functions allowing to control the OPAMP data
967 transfers.
968
969
970
971 @endverbatim
972 * @{
973 */
974
975 /**
976 * @brief Lock the selected opamp configuration.
977 * Caution: On STM32L1, HAL OPAMP lock is software lock only
978 * (not hardware lock as available on some other STM32 devices)
979 * @param hopamp OPAMP handle
980 * @retval HAL status
981 */
HAL_OPAMP_Lock(OPAMP_HandleTypeDef * hopamp)982 HAL_StatusTypeDef HAL_OPAMP_Lock(OPAMP_HandleTypeDef* hopamp)
983 {
984 HAL_StatusTypeDef status = HAL_OK;
985
986 /* Check the OPAMP handle allocation */
987 /* Check if OPAMP locked */
988 /* OPAMP can be locked when enabled and running in normal mode */
989 /* It is meaningless otherwise */
990 if(hopamp == NULL)
991 {
992 status = HAL_ERROR;
993 }
994 else if(hopamp->State == HAL_OPAMP_STATE_BUSY)
995 {
996 /* Check the parameter */
997 assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
998
999 /* OPAMP state changed to locked */
1000 hopamp->State = HAL_OPAMP_STATE_BUSYLOCKED;
1001 }
1002 else
1003 {
1004 status = HAL_ERROR;
1005 }
1006 return status;
1007 }
1008
1009 /**
1010 * @brief Return the OPAMP factory trimming value
1011 * Caution: On STM32L1 OPAMP, user can retrieve factory trimming if
1012 * OPAMP has never been set to user trimming before.
1013 * Therefore, this function must be called when OPAMP init
1014 * parameter "UserTrimming" is set to trimming factory,
1015 * and before OPAMP calibration (function
1016 * "HAL_OPAMP_SelfCalibrate()").
1017 * Otherwise, factory trimming value cannot be retrieved and
1018 * error status is returned.
1019 * @param hopamp OPAMP handle
1020 * @param trimmingoffset Trimming offset (P or N)
1021 * This parameter must be a value of @ref OPAMP_FactoryTrimming
1022 * @note Calibration parameter retrieved is corresponding to the mode
1023 * specified in OPAMP init structure (mode normal or low-power).
1024 * To retrieve calibration parameters for both modes, repeat this
1025 * function after OPAMP init structure accordingly updated.
1026 * @retval Trimming value (P or N) range: 0->31
1027 * or OPAMP_FACTORYTRIMMING_DUMMY if trimming value is not available
1028 *
1029 */
HAL_OPAMP_GetTrimOffset(OPAMP_HandleTypeDef * hopamp,uint32_t trimmingoffset)1030 HAL_OPAMP_TrimmingValueTypeDef HAL_OPAMP_GetTrimOffset (OPAMP_HandleTypeDef *hopamp, uint32_t trimmingoffset)
1031 {
1032 HAL_OPAMP_TrimmingValueTypeDef trimmingvalue;
1033 __IO uint32_t* tmp_opamp_reg_trimming; /* Selection of register of trimming depending on power mode: OTR or LPOTR */
1034
1035 /* Check the OPAMP handle allocation */
1036 /* Value can be retrieved in HAL_OPAMP_STATE_READY state */
1037 if(hopamp == NULL)
1038 {
1039 return OPAMP_FACTORYTRIMMING_DUMMY;
1040 }
1041
1042 /* Check the OPAMP handle allocation */
1043 /* Value can be retrieved in HAL_OPAMP_STATE_READY state */
1044 if(hopamp->State == HAL_OPAMP_STATE_READY)
1045 {
1046 /* Check the parameter */
1047 assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
1048 assert_param(IS_OPAMP_FACTORYTRIMMING(trimmingoffset));
1049 assert_param(IS_OPAMP_POWERMODE(hopamp->Init.PowerMode));
1050
1051 /* Check the trimming mode */
1052 if (hopamp->Init.UserTrimming == OPAMP_TRIMMING_USER)
1053 {
1054 /* This function must called when OPAMP init parameter "UserTrimming" */
1055 /* is set to trimming factory, and before OPAMP calibration (function */
1056 /* "HAL_OPAMP_SelfCalibrate()"). */
1057 /* Otherwise, factory trimming value cannot be retrieved and error */
1058 /* status is returned. */
1059 trimmingvalue = OPAMP_FACTORYTRIMMING_DUMMY;
1060 }
1061 else
1062 {
1063 /* Select trimming settings depending on power mode */
1064 if (hopamp->Init.PowerMode == OPAMP_POWERMODE_NORMAL)
1065 {
1066 tmp_opamp_reg_trimming = &OPAMP->OTR;
1067 }
1068 else
1069 {
1070 tmp_opamp_reg_trimming = &OPAMP->LPOTR;
1071 }
1072
1073 /* Get factory trimming */
1074 trimmingvalue = ((*tmp_opamp_reg_trimming >> OPAMP_OFFSET_TRIM_BITSPOSITION(hopamp, trimmingoffset)) & OPAMP_TRIM_VALUE_MASK);
1075 }
1076 }
1077 else
1078 {
1079 return OPAMP_FACTORYTRIMMING_DUMMY;
1080 }
1081 return trimmingvalue;
1082 }
1083
1084 /**
1085 * @}
1086 */
1087
1088
1089 /** @defgroup OPAMP_Exported_Functions_Group4 Peripheral State functions
1090 * @brief Peripheral State functions
1091 *
1092 @verbatim
1093 ===============================================================================
1094 ##### Peripheral State functions #####
1095 ===============================================================================
1096 [..]
1097 This subsection permits to get in run-time the status of the peripheral.
1098
1099 @endverbatim
1100 * @{
1101 */
1102
1103 /**
1104 * @brief Return the OPAMP handle state.
1105 * @param hopamp OPAMP handle
1106 * @retval HAL state
1107 */
HAL_OPAMP_GetState(OPAMP_HandleTypeDef * hopamp)1108 HAL_OPAMP_StateTypeDef HAL_OPAMP_GetState(OPAMP_HandleTypeDef* hopamp)
1109 {
1110 /* Check the OPAMP handle allocation */
1111 if(hopamp == NULL)
1112 {
1113 return HAL_OPAMP_STATE_RESET;
1114 }
1115
1116 /* Check the parameter */
1117 assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
1118
1119 return hopamp->State;
1120 }
1121
1122 #if (USE_HAL_OPAMP_REGISTER_CALLBACKS == 1)
1123 /**
1124 * @brief Register a User OPAMP Callback
1125 * To be used instead of the weak (overridden) predefined callback
1126 * @param hopamp OPAMP handle
1127 * @param CallbackID ID of the callback to be registered
1128 * This parameter can be one of the following values:
1129 * @arg @ref HAL_OPAMP_MSPINIT_CB_ID OPAMP MspInit callback ID
1130 * @arg @ref HAL_OPAMP_MSPDEINIT_CB_ID OPAMP MspDeInit callback ID
1131 * @param pCallback pointer to the Callback function
1132 * @retval status
1133 */
HAL_OPAMP_RegisterCallback(OPAMP_HandleTypeDef * hopamp,HAL_OPAMP_CallbackIDTypeDef CallbackID,pOPAMP_CallbackTypeDef pCallback)1134 HAL_StatusTypeDef HAL_OPAMP_RegisterCallback (OPAMP_HandleTypeDef *hopamp, HAL_OPAMP_CallbackIDTypeDef CallbackID, pOPAMP_CallbackTypeDef pCallback)
1135 {
1136 HAL_StatusTypeDef status = HAL_OK;
1137
1138 if(pCallback == NULL)
1139 {
1140 return HAL_ERROR;
1141 }
1142
1143 /* Process locked */
1144 __HAL_LOCK(hopamp);
1145
1146 if(hopamp->State == HAL_OPAMP_STATE_READY)
1147 {
1148 switch (CallbackID)
1149 {
1150 case HAL_OPAMP_MSPINIT_CB_ID :
1151 hopamp->MspInitCallback = pCallback;
1152 break;
1153 case HAL_OPAMP_MSPDEINIT_CB_ID :
1154 hopamp->MspDeInitCallback = pCallback;
1155 break;
1156 default :
1157 /* Update the error code */
1158 // hopamp->ErrorCode |= HAL_OPAMP_ERROR_INVALID_CALLBACK;
1159 /* update return status */
1160 status = HAL_ERROR;
1161 break;
1162 }
1163 }
1164 else if (hopamp->State == HAL_OPAMP_STATE_RESET)
1165 {
1166 switch (CallbackID)
1167 {
1168 case HAL_OPAMP_MSPINIT_CB_ID :
1169 hopamp->MspInitCallback = pCallback;
1170 break;
1171 case HAL_OPAMP_MSPDEINIT_CB_ID :
1172 hopamp->MspDeInitCallback = pCallback;
1173 break;
1174 default :
1175 /* Update the error code */
1176 // hopamp->ErrorCode |= HAL_OPAMP_ERROR_INVALID_CALLBACK;
1177 /* update return status */
1178 status = HAL_ERROR;
1179 break;
1180 }
1181 }
1182 else
1183 {
1184 /* update return status */
1185 status = HAL_ERROR;
1186 }
1187
1188 /* Release Lock */
1189 __HAL_UNLOCK(hopamp);
1190 return status;
1191 }
1192
1193 /**
1194 * @brief Unregister a User OPAMP Callback
1195 * OPAMP Callback is redirected to the weak (overridden) predefined callback
1196 * @param hopamp OPAMP handle
1197 * @param CallbackID ID of the callback to be unregistered
1198 * This parameter can be one of the following values:
1199 * @arg @ref HAL_OPAMP_MSPINIT_CB_ID OPAMP MSP Init Callback ID
1200 * @arg @ref HAL_OPAMP_MSPDEINIT_CB_ID OPAMP MSP DeInit Callback ID
1201 * @arg @ref HAL_OPAMP_ALL_CB_ID OPAMP All Callbacks
1202 * @retval status
1203 */
1204
HAL_OPAMP_UnRegisterCallback(OPAMP_HandleTypeDef * hopamp,HAL_OPAMP_CallbackIDTypeDef CallbackID)1205 HAL_StatusTypeDef HAL_OPAMP_UnRegisterCallback (OPAMP_HandleTypeDef *hopamp, HAL_OPAMP_CallbackIDTypeDef CallbackID)
1206 {
1207 HAL_StatusTypeDef status = HAL_OK;
1208
1209 /* Process locked */
1210 __HAL_LOCK(hopamp);
1211
1212 if(hopamp->State == HAL_OPAMP_STATE_READY)
1213 {
1214 switch (CallbackID)
1215 {
1216 case HAL_OPAMP_MSPINIT_CB_ID :
1217 hopamp->MspInitCallback = HAL_OPAMP_MspInit;
1218 break;
1219 case HAL_OPAMP_MSPDEINIT_CB_ID :
1220 hopamp->MspDeInitCallback = HAL_OPAMP_MspDeInit;
1221 break;
1222 case HAL_OPAMP_ALL_CB_ID :
1223 hopamp->MspInitCallback = HAL_OPAMP_MspInit;
1224 hopamp->MspDeInitCallback = HAL_OPAMP_MspDeInit;
1225 break;
1226 default :
1227 /* update return status */
1228 status = HAL_ERROR;
1229 break;
1230 }
1231 }
1232 else if (hopamp->State == HAL_OPAMP_STATE_RESET)
1233 {
1234 switch (CallbackID)
1235 {
1236 case HAL_OPAMP_MSPINIT_CB_ID :
1237 hopamp->MspInitCallback = HAL_OPAMP_MspInit;
1238 break;
1239 case HAL_OPAMP_MSPDEINIT_CB_ID :
1240 hopamp->MspDeInitCallback = HAL_OPAMP_MspDeInit;
1241 break;
1242 default :
1243 /* update return status */
1244 status = HAL_ERROR;
1245 break;
1246 }
1247 }
1248 else
1249 {
1250 /* update return status */
1251 status = HAL_ERROR;
1252 }
1253
1254 /* Release Lock */
1255 __HAL_UNLOCK(hopamp);
1256 return status;
1257 }
1258
1259 #endif /* USE_HAL_OPAMP_REGISTER_CALLBACKS */
1260 /**
1261 * @}
1262 */
1263
1264 /**
1265 * @}
1266 */
1267
1268 #endif /* STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L151xDX || STM32L152xE || STM32L152xDX || STM32L162xE || STM32L162xDX || STM32L162xC || STM32L152xC || STM32L151xC */
1269
1270 #endif /* HAL_OPAMP_MODULE_ENABLED */
1271 /**
1272 * @}
1273 */
1274
1275 /**
1276 * @}
1277 */
1278
1279
