Published May 27, 2021

STM32 Window Watchdog (WWDG)

Configuring Window watchdog (WWDG) on STM32 Nucleo-F401RE and test it.

IntermediateProtip15,990

Things used in this project

Hardware components

STMicroelectronics STM32 Nucleo-F401RE

Analog Devices Analog Discovery

Good to have but not necessary for this project.

Software apps and online services

STMicroelectronics STM32CubeMX

Keil Embedded Development Tools Keil MDK

Digilent WaveForms

Good to have but not necessary for this project.

Story

STM32F401xD/E has two Watchdog timers- Independent watchdog (IWDG) and Window watchdog (WWDG). In this project we will see how to activate and periodically pet the dog, I mean refresh the watchdog. Also we will see what will happen if you don't pet your watchdog within the window i.e. petting (refreshing) too late or too early.

Some knowledge of STM32CubeMX, Keil MDK, GPIOs, Counters are assumed from the reader to follow along.

Theory

As the name watchdog suggests, it is watching the application running on the MCU. It is a monitoring function. In case of any abnormality from the normal sequence of program execution- software fault, the watchdog detects it. It then initiates a MCU reset, which will help to start the software all over again.

From the functionality stand point, there are two major differences between IWGD and WWDG.

IWDG does not offer a window for refresh. [This means, IWDG doesn't care as long as it is refreshed before the down counter (WWDG_CR[6:0], rolls over]
IWDG offers no Interrupt Service Routine (ISR) where as WWDG does. [This means, just before initiating a reset, an interrupt is generated, where you could write your routine to have a safe exit.]

Unlike IWDG, WWDG is clocked by the APB1 peripheral clock. The following image shows a snapshot form STM32CubeMX.

In this project we will, configure and test these cases.

Case 1: Activate WWDG and we will not refresh the WWDG and check that a reset is triggered, by the time down counter WWDG_CR[6:0] is elapsed. We will monitor the reset line using Digilent- Analog Discovery (Legacy) instrument.
Case 2: Include our routine to refresh it within the window and see that no reset is initiated by the WWDG. [At this point I have not yet explained what this window is. It will get familiar in some time]
Case 3: We will refresh the WWDG too early and check that a reset is triggered.
Case 4: We will enable the EWI interrupt and write a routine to toggle the on-board Green LED there. We will observe on the oscilloscope that the ISR is executed before initiating a MCU reset. This is an advance feature in WWDG which is not available in IWDG.

Start the project..

1. Create a project in STM32CubeMX from the board selector. Refer to the attached file for details- 'Create STM32CubeMX project'.

2. On the left pane, expand- System Core and select- WWDG. A window appears showing WWDG configuration. There click Activated. This activates the WWDG with the default configuration as displayed in the section 3 in the below image.

Lets understand these WWDG Clocking parameters.

WWDG counter clock prescaler: The resulting value of the clock is equal to (PCLK1/4096)/prescaler

PCKL1 is APB1 clock (42MHz for STM32F401RE)
4096 is internal divider

[Prescaler is just a clock divider. Higher the prescaler lower the clock frequency to the counter. Thus longer the counting takes.]

Lets select the prescaler to be 8: (PCLK1/4096)/8

This results in the WWDG clock for down counter to be (42MHz/4096)/8 = 1281.738 Hz. Hence the clock period (1 clock cycle) is ca. 780us

tClkWwdg = 780us

Window: This term in WWDG refers to a time frame within which it is allowed to refresh the watchdog. Out of this zone is interpreted as software fault and MCU reset is initiated by the WWDG. Let us now configure this window. Please find the image below.

WWDG timing diagram from STM32F401RE Reference Manual

The highlighted 3 parameters define the window.

T[6:0] is WWDG_CR[6:0] register for down counter. The max value is 127. Once the watchdog is activated WWDG_CR[7] is set, the count down starts at a rate of tClkWWDG. In this case it is 780us.

W[6:0] is WWDG_CFR[6:0] register for window value that is to be compared to the downcounter during run-time.

0x3F is the lowest limit to which the down counter counts to. Once the counter reaches this value, a reset is triggered.

It is important that the WWDG is serviced (refreshed/updated) when the down counter value is greater than W[6:0] and less than 0x3F. Failing to refresh in this window is interpreted as a software fault by the WWDG and a reset is initiated.

Let us choose some values for the watchdog window.

Prescaler = 8; W = 94; T = 127.

Let us now calculate the timing.

Time taken by the down counter to count down from 127 to 63 is tWWDG = tClkWWDG * (127 - 63) = 49.92ms

No refresh is allowed from the start of the down counter 127 till it reaches 94, i.e. tNoRefr = tClkWWDG * (127-94) = 25.74ms

Refresh is allowed after tNoRefr and before tWWDG.

Lets get back to CubeMX, switch to Project Manager perspective and select Keil MDK, save the project and hit - 'Generate code'.

Note that Watchdog Interrupt (Early Wakeup Interrupt- EWI) is kept disabled. We will get to it at a later part.

STM32CubeMX Project Manager perspective

Select Open project and the Keil MDK IDE opens up. As shown in the image below, open the main.c file.

Keil MDK- main.c

Build the project and see that there are no errors.

Right click on the watchdog init function and select go to definition.

static void MX_WWDG_Init(void);

Note that the parameters are as we specified in CubeMX.

Also feel free to have a look at the source file- stm32f4xx_it.c, for EXTI (External interrupt/event controller) routines. For the moment we have not configured any interrupts. In the later part we will have a deeper look at it.

Deploy and test:

Without wasting much time lets just build the project and deploy it to our ST32F401RE Nucleo board.

Case 1:

Since we are not servicing yet the WWDG, after the down counter reaches 0x3F, a MCU reset will be triggered. We will connect Oscilloscope channel 1 of the super useful Digilent Analog Discovery to the Reset line and monitor it.

Our expectation, reset is triggered by the WWDG every ca.50ms.

CN4- Pin 5 is NRST

Please refer to the two images below for reference.

Snapshot from Schematics

Open Digilent Waveforms. I have configured channel 1 with some measurement options- x cursors, that will help us see the frequency of reset occurrence.

Build the project and hit the debug button.

Let us monitor the CRC register from the RCC peripheral. Window watchdog reset flag (WWDGRSTF) and Remove reset flag (RMVF) are of interest in the CRC register. Please go through the STM32 MCU reference manual for details. I have just provided these two images of RCC_CRC register for convenience.

Coming back to Keil..

The code is still halted. You will notice that we have some reset flags set. Clear all the resets before proceeding to have a clean setup.

Click RMVF bit

Hit Run (F5) to start the program

You will immediately see WWDGRSTF getting set.

We can see that as expected reset line is toggled every ca. 52ms.

Case 2:

Let us pet our dog so that it does't bark. Ok..I mean lets refresh our WWDG within the window and see what happens..

Go to main.c. If you are still in degug mode, exit the debug perspective. Include this snippet of code in the infinite while loop.

HAL_Delay(30);
HAL_WWDG_Refresh(&hwwdg);

HAL_Delay(30) halts the MCU for 30ms. We wait for 30ms and refresh the WWDG. As it might be clear by now that we can't refresh the watch dog for a duration of tNoRefr (25.74ms).

The outcome.. there should be any reset triggered by the WWDG. Lets build the project and check it..

Follow the same steps as before to build the project and open it in debug mode. Set the RMVF bit to clear the reset flags and Run the program. You should see that WWDGRSTF flag to be always clear.

No reset. Our dog is happy :)

Case 3:

We will refresh the WWDG too early and check that a reset is triggered.

Modify the delay value from 30ms to anything less than tNoRefr (25.74ms).

I choose 15ms.

Result:

Since we are refreshing the WWDG much soon, a reset is triggered every 18ms.

Case 4:

The most interesting part. We should not forget that WWDG has a beatiful feature - it generates an interrupt just before triggering a rest. This will help us to exit in a safe state, say take a snapshot of the system and store to EEPROM may be.

Lets check this functionality by enabling the EWI interrupt and write a routine to toggle the on-board Green LED. We will observe on the oscilloscope that the ISR is executed before initiating a MCU reset. This is an advance feature in WWDG which is not available in IWDG.

You could use CubeMX to enable the EWI graphically as shown below.

This is just not sufficient. We need to enable the Watchdog interrupt in NVIC settings. Without enabling the global watchdog interrupt just enabling EWI does not work as the interrupt will not be able to pass through the Interrupt Controler- NVIC. I highly recommend you to go through the EXTI section in the reference manual for more details as this is beyond the scope of this article.

Save the project and build. This time when you switch back to Keil, it should ask you that the files are updated and do you want to load them. Say, yes.

Now you should have the latest files in your Keil project. Go to the file stm32f4xx_it.c. You will see at the end this extra piece of code is added (in the red box). It is the WWDG interrupt handler.

Go to the definition of HAL_WWDG_IRQHandler(&hwwdg); indicated in the blue box.

We can see that the early wakeup callback is enabled and __weak function is created for us. Copy the function and paste it in the main.c and remove __weak. Thats where we will write our routine to toggle the on-board Green LED to see if the ISR is executed before reset is initiated. Please see the image below indicating the location where it has to be copied in main.c. Do it after all the peripheral initialization functions are completed and in between user code begin and end.

Lets remove all the content from the function body and toggle our on-board LED.

Also, comment out the code written inside while(1) infinite loop. This time we will let the down counter elapse and expect that the WWDG resets the MCU. But before doing that we want it to service our interrupt. This we will monitor by toggling the led every 20ms.

Please follow the same steps as before to build the project and open it in debug mode. Set the RMVF bit to clear the reset flags and Run the program.

Result:

Please refer to the video showing toggling on-board Green LED-

Oscilloscope:

Ch1: NRST

Ch2: LED

We can see that the Interrupt is generated ca. 780us before reset, which is exactly one WWDG clock cycle before. But the reset is triggered every 52ms, i.e. only after the down counter counts down to 0x3F (decimal: 63).

Note: In case if you need complete information about HAL libraries for STM32F4 and how to use them, please refer to the manual UM1725. Description of STM32F4 HAL and low-layer drivers

Conclusion

We have configured and tested the Window watchdog of STM32F401RE in various scenarios. In Case 4, we see something quite interesting. The on-board led is not being toggled every 20ms. The reset is forcing the led to turn off as the WWDG is giving the MCU only 1 clock cycle to do anything important. As the reset happens every 52ms, we might misinterpret the LED toggling as our ISR routine. In fact the HAL_GPIO_TogglePin() is not even fully executed. It is broken by the reset. Try to comment out the HAL_Delay(), try to replace HAL_GPIO_TogglePin() to HAL_GPO_WritePin() and see what happens.

Also with the EWI enabled, try to refresh the WWDG too early and see if ISR is executed. Let me know if you have any questions. I would be happy to hear your feedback. Thanks for the read!

Code

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2021 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
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
UART_HandleTypeDef huart2;

WWDG_HandleTypeDef hwwdg;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_WWDG_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART2_UART_Init();
  MX_WWDG_Init();
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
		//HAL_Delay(20);
		//HAL_WWDG_Refresh(&hwwdg);
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);
  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 16;
  RCC_OscInitStruct.PLL.PLLN = 336;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
  RCC_OscInitStruct.PLL.PLLQ = 7;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief USART2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART2_UART_Init(void)
{

  /* USER CODE BEGIN USART2_Init 0 */

  /* USER CODE END USART2_Init 0 */

  /* USER CODE BEGIN USART2_Init 1 */

  /* USER CODE END USART2_Init 1 */
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART2_Init 2 */
	

  /* USER CODE END USART2_Init 2 */

}

/**
  * @brief WWDG Initialization Function
  * @param None
  * @retval None
  */
static void MX_WWDG_Init(void)
{

  /* USER CODE BEGIN WWDG_Init 0 */

  /* USER CODE END WWDG_Init 0 */

  /* USER CODE BEGIN WWDG_Init 1 */

  /* USER CODE END WWDG_Init 1 */
  hwwdg.Instance = WWDG;
  hwwdg.Init.Prescaler = WWDG_PRESCALER_8;
  hwwdg.Init.Window = 94;
  hwwdg.Init.Counter = 127;
  hwwdg.Init.EWIMode = WWDG_EWI_ENABLE;
  if (HAL_WWDG_Init(&hwwdg) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN WWDG_Init 2 */

  /* USER CODE END WWDG_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin : B1_Pin */
  GPIO_InitStruct.Pin = B1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(B1_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : LD2_Pin */
  GPIO_InitStruct.Pin = LD2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(LD2_GPIO_Port, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */
void HAL_WWDG_EarlyWakeupCallback(WWDG_HandleTypeDef *hwwdg)
{
	HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET); //PA5 is on-board green led.
	HAL_Delay(20); //20 ms delay
}

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    stm32f4xx_it.c
  * @brief   Interrupt Service Routines.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2021 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
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "stm32f4xx_it.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN TD */

/* USER CODE END TD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/* External variables --------------------------------------------------------*/
extern WWDG_HandleTypeDef hwwdg;
/* USER CODE BEGIN EV */

/* USER CODE END EV */

/******************************************************************************/
/*           Cortex-M4 Processor Interruption and Exception Handlers          */
/******************************************************************************/
/**
  * @brief This function handles Non maskable interrupt.
  */
void NMI_Handler(void)
{
  /* USER CODE BEGIN NonMaskableInt_IRQn 0 */

  /* USER CODE END NonMaskableInt_IRQn 0 */
  /* USER CODE BEGIN NonMaskableInt_IRQn 1 */
  while (1)
  {
  }
  /* USER CODE END NonMaskableInt_IRQn 1 */
}

/**
  * @brief This function handles Hard fault interrupt.
  */
void HardFault_Handler(void)
{
  /* USER CODE BEGIN HardFault_IRQn 0 */

  /* USER CODE END HardFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_HardFault_IRQn 0 */
    /* USER CODE END W1_HardFault_IRQn 0 */
  }
}

/**
  * @brief This function handles Memory management fault.
  */
void MemManage_Handler(void)
{
  /* USER CODE BEGIN MemoryManagement_IRQn 0 */

  /* USER CODE END MemoryManagement_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_MemoryManagement_IRQn 0 */
    /* USER CODE END W1_MemoryManagement_IRQn 0 */
  }
}

/**
  * @brief This function handles Pre-fetch fault, memory access fault.
  */
void BusFault_Handler(void)
{
  /* USER CODE BEGIN BusFault_IRQn 0 */

  /* USER CODE END BusFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_BusFault_IRQn 0 */
    /* USER CODE END W1_BusFault_IRQn 0 */
  }
}

/**
  * @brief This function handles Undefined instruction or illegal state.
  */
void UsageFault_Handler(void)
{
  /* USER CODE BEGIN UsageFault_IRQn 0 */

  /* USER CODE END UsageFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_UsageFault_IRQn 0 */
    /* USER CODE END W1_UsageFault_IRQn 0 */
  }
}

/**
  * @brief This function handles System service call via SWI instruction.
  */
void SVC_Handler(void)
{
  /* USER CODE BEGIN SVCall_IRQn 0 */

  /* USER CODE END SVCall_IRQn 0 */
  /* USER CODE BEGIN SVCall_IRQn 1 */

  /* USER CODE END SVCall_IRQn 1 */
}

/**
  * @brief This function handles Debug monitor.
  */
void DebugMon_Handler(void)
{
  /* USER CODE BEGIN DebugMonitor_IRQn 0 */

  /* USER CODE END DebugMonitor_IRQn 0 */
  /* USER CODE BEGIN DebugMonitor_IRQn 1 */

  /* USER CODE END DebugMonitor_IRQn 1 */
}

/**
  * @brief This function handles Pendable request for system service.
  */
void PendSV_Handler(void)
{
  /* USER CODE BEGIN PendSV_IRQn 0 */

  /* USER CODE END PendSV_IRQn 0 */
  /* USER CODE BEGIN PendSV_IRQn 1 */

  /* USER CODE END PendSV_IRQn 1 */
}

/**
  * @brief This function handles System tick timer.
  */
void SysTick_Handler(void)
{
  /* USER CODE BEGIN SysTick_IRQn 0 */

  /* USER CODE END SysTick_IRQn 0 */
  HAL_IncTick();
  /* USER CODE BEGIN SysTick_IRQn 1 */

  /* USER CODE END SysTick_IRQn 1 */
}

/******************************************************************************/
/* STM32F4xx Peripheral Interrupt Handlers                                    */
/* Add here the Interrupt Handlers for the used peripherals.                  */
/* For the available peripheral interrupt handler names,                      */
/* please refer to the startup file (startup_stm32f4xx.s).                    */
/******************************************************************************/

/**
  * @brief This function handles Window watchdog interrupt.
  */
void WWDG_IRQHandler(void)
{
  /* USER CODE BEGIN WWDG_IRQn 0 */

  /* USER CODE END WWDG_IRQn 0 */
  HAL_WWDG_IRQHandler(&hwwdg);
  /* USER CODE BEGIN WWDG_IRQn 1 */

  /* USER CODE END WWDG_IRQn 1 */
}

/* USER CODE BEGIN 1 */

/* USER CODE END 1 */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

Credits

Sameera Kumar Kambadur

2 projects • 6 followers

STM32 Window Watchdog (WWDG)

Things used in this project

Hardware components

Software apps and online services

Story

Theory

Start the project..

Case 1:

Coming back to Keil..

Case 2:

Case 3:

Case 4:

Conclusion

Schematics

Create STM32CubeMX project

WWDG_EWI_ISR_ToggleLED.mp4

Code

main.c

stm32f4xx_it.c

Credits

Sameera Kumar Kambadur

Comments

Embed the widget on your own site

STM32 Window Watchdog (WWDG)

STM32 Window Watchdog (WWDG)

Things used in this project

Hardware components

Software apps and online services

Story

Theory

Start the project..

Case 1:

Coming back to Keil..

Case 2:

Case 3:

Case 4:

Conclusion

Schematics

Create STM32CubeMX project

WWDG_EWI_ISR_ToggleLED.mp4

Code

main.c

stm32f4xx_it.c

Credits

Sameera Kumar Kambadur

Comments

Related channels and tags