stm32f4xx_hal_wwdg.c
1 /** 2 ****************************************************************************** 3 * @file stm32f4xx_hal_wwdg.c 4 * @author MCD Application Team 5 * @brief WWDG HAL module driver. 6 * This file provides firmware functions to manage the following 7 * functionalities of the Window Watchdog (WWDG) peripheral: 8 * + Initialization and Configuration functions 9 * + IO operation functions 10 ****************************************************************************** 11 * @attention 12 * 13 * Copyright (c) 2016 STMicroelectronics. 14 * All rights reserved. 15 * 16 * This software is licensed under terms that can be found in the LICENSE file 17 * in the root directory of this software component. 18 * If no LICENSE file comes with this software, it is provided AS-IS. 19 * 20 ****************************************************************************** 21 @verbatim 22 ============================================================================== 23 ##### WWDG Specific features ##### 24 ============================================================================== 25 [..] 26 Once enabled the WWDG generates a system reset on expiry of a programmed 27 time period, unless the program refreshes the counter (T[6;0] downcounter) 28 before reaching 0x3F value (i.e. a reset is generated when the counter 29 value rolls down from 0x40 to 0x3F). 30 31 (+) An MCU reset is also generated if the counter value is refreshed 32 before the counter has reached the refresh window value. This 33 implies that the counter must be refreshed in a limited window. 34 (+) Once enabled the WWDG cannot be disabled except by a system reset. 35 (+) If required by application, an Early Wakeup Interrupt can be triggered 36 in order to be warned before WWDG expiration. The Early Wakeup Interrupt 37 (EWI) can be used if specific safety operations or data logging must 38 be performed before the actual reset is generated. When the downcounter 39 reaches 0x40, interrupt occurs. This mechanism requires WWDG interrupt 40 line to be enabled in NVIC. Once enabled, EWI interrupt cannot be 41 disabled except by a system reset. 42 (+) WWDGRST flag in RCC CSR register can be used to inform when a WWDG 43 reset occurs. 44 (+) The WWDG counter input clock is derived from the APB clock divided 45 by a programmable prescaler. 46 (+) WWDG clock (Hz) = PCLK1 / (4096 * Prescaler) 47 (+) WWDG timeout (mS) = 1000 * (T[5;0] + 1) / WWDG clock (Hz) 48 where T[5;0] are the lowest 6 bits of Counter. 49 (+) WWDG Counter refresh is allowed between the following limits : 50 (++) min time (mS) = 1000 * (Counter - Window) / WWDG clock 51 (++) max time (mS) = 1000 * (Counter - 0x40) / WWDG clock 52 (+) Typical values: 53 (++) Counter min (T[5;0] = 0x00) at 42MHz (PCLK1) with zero prescaler: 54 max timeout before reset: approximately 97.52us 55 (++) Counter max (T[5;0] = 0x3F) at 42MHz (PCLK1) with prescaler 56 dividing by 8: 57 max timeout before reset: approximately 49.93ms 58 59 ##### How to use this driver ##### 60 ============================================================================== 61 62 *** Common driver usage *** 63 =========================== 64 65 [..] 66 (+) Enable WWDG APB1 clock using __HAL_RCC_WWDG_CLK_ENABLE(). 67 (+) Configure the WWDG prescaler, refresh window value, counter value and early 68 interrupt status using HAL_WWDG_Init() function. This will automatically 69 enable WWDG and start its downcounter. Time reference can be taken from 70 function exit. Care must be taken to provide a counter value 71 greater than 0x40 to prevent generation of immediate reset. 72 (+) If the Early Wakeup Interrupt (EWI) feature is enabled, an interrupt is 73 generated when the counter reaches 0x40. When HAL_WWDG_IRQHandler is 74 triggered by the interrupt service routine, flag will be automatically 75 cleared and HAL_WWDG_WakeupCallback user callback will be executed. User 76 can add his own code by customization of callback HAL_WWDG_WakeupCallback. 77 (+) Then the application program must refresh the WWDG counter at regular 78 intervals during normal operation to prevent an MCU reset, using 79 HAL_WWDG_Refresh() function. This operation must occur only when 80 the counter is lower than the refresh window value already programmed. 81 82 *** Callback registration *** 83 ============================= 84 85 [..] 86 The compilation define USE_HAL_WWDG_REGISTER_CALLBACKS when set to 1 allows 87 the user to configure dynamically the driver callbacks. Use Functions 88 HAL_WWDG_RegisterCallback() to register a user callback. 89 90 (+) Function HAL_WWDG_RegisterCallback() allows to register following 91 callbacks: 92 (++) EwiCallback : callback for Early WakeUp Interrupt. 93 (++) MspInitCallback : WWDG MspInit. 94 This function takes as parameters the HAL peripheral handle, the Callback ID 95 and a pointer to the user callback function. 96 97 (+) Use function HAL_WWDG_UnRegisterCallback() to reset a callback to 98 the default weak (surcharged) function. HAL_WWDG_UnRegisterCallback() 99 takes as parameters the HAL peripheral handle and the Callback ID. 100 This function allows to reset following callbacks: 101 (++) EwiCallback : callback for Early WakeUp Interrupt. 102 (++) MspInitCallback : WWDG MspInit. 103 104 [..] 105 When calling HAL_WWDG_Init function, callbacks are reset to the 106 corresponding legacy weak (surcharged) functions: 107 HAL_WWDG_EarlyWakeupCallback() and HAL_WWDG_MspInit() only if they have 108 not been registered before. 109 110 [..] 111 When compilation define USE_HAL_WWDG_REGISTER_CALLBACKS is set to 0 or 112 not defined, the callback registering feature is not available 113 and weak (surcharged) callbacks are used. 114 115 *** WWDG HAL driver macros list *** 116 =================================== 117 [..] 118 Below the list of available macros in WWDG HAL driver. 119 (+) __HAL_WWDG_ENABLE: Enable the WWDG peripheral 120 (+) __HAL_WWDG_GET_FLAG: Get the selected WWDG's flag status 121 (+) __HAL_WWDG_CLEAR_FLAG: Clear the WWDG's pending flags 122 (+) __HAL_WWDG_ENABLE_IT: Enable the WWDG early wakeup interrupt 123 124 @endverbatim 125 ****************************************************************************** 126 */ 127 128 /* Includes ------------------------------------------------------------------*/ 129 #include "stm32f4xx_hal.h" 130 131 /** @addtogroup STM32F4xx_HAL_Driver 132 * @{ 133 */ 134 135 #ifdef HAL_WWDG_MODULE_ENABLED 136 /** @defgroup WWDG WWDG 137 * @brief WWDG HAL module driver. 138 * @{ 139 */ 140 141 /* Private typedef -----------------------------------------------------------*/ 142 /* Private define ------------------------------------------------------------*/ 143 /* Private macro -------------------------------------------------------------*/ 144 /* Private variables ---------------------------------------------------------*/ 145 /* Private function prototypes -----------------------------------------------*/ 146 /* Exported functions --------------------------------------------------------*/ 147 148 /** @defgroup WWDG_Exported_Functions WWDG Exported Functions 149 * @{ 150 */ 151 152 /** @defgroup WWDG_Exported_Functions_Group1 Initialization and Configuration functions 153 * @brief Initialization and Configuration functions. 154 * 155 @verbatim 156 ============================================================================== 157 ##### Initialization and Configuration functions ##### 158 ============================================================================== 159 [..] 160 This section provides functions allowing to: 161 (+) Initialize and start the WWDG according to the specified parameters 162 in the WWDG_InitTypeDef of associated handle. 163 (+) Initialize the WWDG MSP. 164 165 @endverbatim 166 * @{ 167 */ 168 169 /** 170 * @brief Initialize the WWDG according to the specified. 171 * parameters in the WWDG_InitTypeDef of associated handle. 172 * @param hwwdg pointer to a WWDG_HandleTypeDef structure that contains 173 * the configuration information for the specified WWDG module. 174 * @retval HAL status 175 */ 176 HAL_StatusTypeDef HAL_WWDG_Init(WWDG_HandleTypeDef *hwwdg) 177 { 178 /* Check the WWDG handle allocation */ 179 if (hwwdg == NULL) 180 { 181 return HAL_ERROR; 182 } 183 184 /* Check the parameters */ 185 assert_param(IS_WWDG_ALL_INSTANCE(hwwdg->Instance)); 186 assert_param(IS_WWDG_PRESCALER(hwwdg->Init.Prescaler)); 187 assert_param(IS_WWDG_WINDOW(hwwdg->Init.Window)); 188 assert_param(IS_WWDG_COUNTER(hwwdg->Init.Counter)); 189 assert_param(IS_WWDG_EWI_MODE(hwwdg->Init.EWIMode)); 190 191 #if (USE_HAL_WWDG_REGISTER_CALLBACKS == 1) 192 /* Reset Callback pointers */ 193 if (hwwdg->EwiCallback == NULL) 194 { 195 hwwdg->EwiCallback = HAL_WWDG_EarlyWakeupCallback; 196 } 197 198 if (hwwdg->MspInitCallback == NULL) 199 { 200 hwwdg->MspInitCallback = HAL_WWDG_MspInit; 201 } 202 203 /* Init the low level hardware */ 204 hwwdg->MspInitCallback(hwwdg); 205 #else 206 /* Init the low level hardware */ 207 HAL_WWDG_MspInit(hwwdg); 208 #endif /* USE_HAL_WWDG_REGISTER_CALLBACKS */ 209 210 /* Set WWDG Counter */ 211 WRITE_REG(hwwdg->Instance->CR, (WWDG_CR_WDGA | hwwdg->Init.Counter)); 212 213 /* Set WWDG Prescaler and Window */ 214 WRITE_REG(hwwdg->Instance->CFR, (hwwdg->Init.EWIMode | hwwdg->Init.Prescaler | hwwdg->Init.Window)); 215 216 /* Return function status */ 217 return HAL_OK; 218 } 219 220 221 /** 222 * @brief Initialize the WWDG MSP. 223 * @param hwwdg pointer to a WWDG_HandleTypeDef structure that contains 224 * the configuration information for the specified WWDG module. 225 * @note When rewriting this function in user file, mechanism may be added 226 * to avoid multiple initialize when HAL_WWDG_Init function is called 227 * again to change parameters. 228 * @retval None 229 */ 230 __weak void HAL_WWDG_MspInit(WWDG_HandleTypeDef *hwwdg) 231 { 232 /* Prevent unused argument(s) compilation warning */ 233 UNUSED(hwwdg); 234 235 /* NOTE: This function should not be modified, when the callback is needed, 236 the HAL_WWDG_MspInit could be implemented in the user file 237 */ 238 } 239 240 241 #if (USE_HAL_WWDG_REGISTER_CALLBACKS == 1) 242 /** 243 * @brief Register a User WWDG Callback 244 * To be used instead of the weak (surcharged) predefined callback 245 * @param hwwdg WWDG handle 246 * @param CallbackID ID of the callback to be registered 247 * This parameter can be one of the following values: 248 * @arg @ref HAL_WWDG_EWI_CB_ID Early WakeUp Interrupt Callback ID 249 * @arg @ref HAL_WWDG_MSPINIT_CB_ID MspInit callback ID 250 * @param pCallback pointer to the Callback function 251 * @retval status 252 */ 253 HAL_StatusTypeDef HAL_WWDG_RegisterCallback(WWDG_HandleTypeDef *hwwdg, HAL_WWDG_CallbackIDTypeDef CallbackID, 254 pWWDG_CallbackTypeDef pCallback) 255 { 256 HAL_StatusTypeDef status = HAL_OK; 257 258 if (pCallback == NULL) 259 { 260 status = HAL_ERROR; 261 } 262 else 263 { 264 switch (CallbackID) 265 { 266 case HAL_WWDG_EWI_CB_ID: 267 hwwdg->EwiCallback = pCallback; 268 break; 269 270 case HAL_WWDG_MSPINIT_CB_ID: 271 hwwdg->MspInitCallback = pCallback; 272 break; 273 274 default: 275 status = HAL_ERROR; 276 break; 277 } 278 } 279 280 return status; 281 } 282 283 284 /** 285 * @brief Unregister a WWDG Callback 286 * WWDG Callback is redirected to the weak (surcharged) predefined callback 287 * @param hwwdg WWDG handle 288 * @param CallbackID ID of the callback to be registered 289 * This parameter can be one of the following values: 290 * @arg @ref HAL_WWDG_EWI_CB_ID Early WakeUp Interrupt Callback ID 291 * @arg @ref HAL_WWDG_MSPINIT_CB_ID MspInit callback ID 292 * @retval status 293 */ 294 HAL_StatusTypeDef HAL_WWDG_UnRegisterCallback(WWDG_HandleTypeDef *hwwdg, HAL_WWDG_CallbackIDTypeDef CallbackID) 295 { 296 HAL_StatusTypeDef status = HAL_OK; 297 298 switch (CallbackID) 299 { 300 case HAL_WWDG_EWI_CB_ID: 301 hwwdg->EwiCallback = HAL_WWDG_EarlyWakeupCallback; 302 break; 303 304 case HAL_WWDG_MSPINIT_CB_ID: 305 hwwdg->MspInitCallback = HAL_WWDG_MspInit; 306 break; 307 308 default: 309 status = HAL_ERROR; 310 break; 311 } 312 313 return status; 314 } 315 #endif /* USE_HAL_WWDG_REGISTER_CALLBACKS */ 316 317 /** 318 * @} 319 */ 320 321 /** @defgroup WWDG_Exported_Functions_Group2 IO operation functions 322 * @brief IO operation functions 323 * 324 @verbatim 325 ============================================================================== 326 ##### IO operation functions ##### 327 ============================================================================== 328 [..] 329 This section provides functions allowing to: 330 (+) Refresh the WWDG. 331 (+) Handle WWDG interrupt request and associated function callback. 332 333 @endverbatim 334 * @{ 335 */ 336 337 /** 338 * @brief Refresh the WWDG. 339 * @param hwwdg pointer to a WWDG_HandleTypeDef structure that contains 340 * the configuration information for the specified WWDG module. 341 * @retval HAL status 342 */ 343 HAL_StatusTypeDef HAL_WWDG_Refresh(WWDG_HandleTypeDef *hwwdg) 344 { 345 /* Write to WWDG CR the WWDG Counter value to refresh with */ 346 WRITE_REG(hwwdg->Instance->CR, (hwwdg->Init.Counter)); 347 348 /* Return function status */ 349 return HAL_OK; 350 } 351 352 /** 353 * @brief Handle WWDG interrupt request. 354 * @note The Early Wakeup Interrupt (EWI) can be used if specific safety operations 355 * or data logging must be performed before the actual reset is generated. 356 * The EWI interrupt is enabled by calling HAL_WWDG_Init function with 357 * EWIMode set to WWDG_EWI_ENABLE. 358 * When the downcounter reaches the value 0x40, and EWI interrupt is 359 * generated and the corresponding Interrupt Service Routine (ISR) can 360 * be used to trigger specific actions (such as communications or data 361 * logging), before resetting the device. 362 * @param hwwdg pointer to a WWDG_HandleTypeDef structure that contains 363 * the configuration information for the specified WWDG module. 364 * @retval None 365 */ 366 void HAL_WWDG_IRQHandler(WWDG_HandleTypeDef *hwwdg) 367 { 368 /* Check if Early Wakeup Interrupt is enable */ 369 if (__HAL_WWDG_GET_IT_SOURCE(hwwdg, WWDG_IT_EWI) != RESET) 370 { 371 /* Check if WWDG Early Wakeup Interrupt occurred */ 372 if (__HAL_WWDG_GET_FLAG(hwwdg, WWDG_FLAG_EWIF) != RESET) 373 { 374 /* Clear the WWDG Early Wakeup flag */ 375 __HAL_WWDG_CLEAR_FLAG(hwwdg, WWDG_FLAG_EWIF); 376 377 #if (USE_HAL_WWDG_REGISTER_CALLBACKS == 1) 378 /* Early Wakeup registered callback */ 379 hwwdg->EwiCallback(hwwdg); 380 #else 381 /* Early Wakeup callback */ 382 HAL_WWDG_EarlyWakeupCallback(hwwdg); 383 #endif /* USE_HAL_WWDG_REGISTER_CALLBACKS */ 384 } 385 } 386 } 387 388 389 /** 390 * @brief WWDG Early Wakeup callback. 391 * @param hwwdg pointer to a WWDG_HandleTypeDef structure that contains 392 * the configuration information for the specified WWDG module. 393 * @retval None 394 */ 395 __weak void HAL_WWDG_EarlyWakeupCallback(WWDG_HandleTypeDef *hwwdg) 396 { 397 /* Prevent unused argument(s) compilation warning */ 398 UNUSED(hwwdg); 399 400 /* NOTE: This function should not be modified, when the callback is needed, 401 the HAL_WWDG_EarlyWakeupCallback could be implemented in the user file 402 */ 403 } 404 405 /** 406 * @} 407 */ 408 409 /** 410 * @} 411 */ 412 413 #endif /* HAL_WWDG_MODULE_ENABLED */ 414 /** 415 * @} 416 */ 417 418 /** 419 * @} 420 */