Watchdog init in the constructor (#59)

Refactor to Watchdog Driver

Author: HardyYu

Boardfiles/nucleol552zeq/Core/Src/main.cpp

@@ -129,7 +129,6 @@ int main(void)
   MX_TIM5_Init();
   MX_ADC1_Init();
   MX_ICACHE_Init();
-  MX_IWDG_Init();
   MX_TIM3_Init();
   MX_SDMMC1_SD_Init();
   if (MX_FATFS_Init() != APP_OK) {

Drivers/iwdg_driver/inc/independent_watchdog.h

@@ -5,12 +5,29 @@
 #include "watchdog.h"
 #include "iwdg.h"
 
+/* 	Reminder for the correct usage of this driver:
+	Don't initialize more than one instance of iwdg.
+	There is only one iwdg in more STM, so it won't work.
+
+	Also, don't call MX_IWDG_Init() in main!
+ */
 class IndependentWatchdog : public Watchdog {
 	private:
-		IWDG_HandleTypeDef* watchdog;
+		IWDG_HandleTypeDef* watchdog_;
+		uint32_t prescaler_;
+		uint32_t window_;
+		uint32_t reload_;
 
+		bool counterCalculation(uint32_t timeout, uint32_t &prescaler, uint32_t &counter);
+		bool windowCalculation(uint32_t timeout, uint32_t prescaler, uint32_t &window);
 	public:
-		IndependentWatchdog(IWDG_HandleTypeDef* watchdog);
+		/* Time out in ms */
+		IndependentWatchdog(uint32_t timeout);
+
+		/* This is very similiar to a Window Watchdog */
+		IndependentWatchdog(uint32_t counter_timeout, uint32_t window_timeout);
+
+		/* Feed the dog and makes it happy */
 		bool refreshWatchdog() override ;
 };
 

Drivers/iwdg_driver/src/independent_watchdog.cpp

@@ -1,12 +1,71 @@
 #include "independent_watchdog.h"
 
-/**
- * @brief Borrow the configuration of an already existing watchdog and set it
- * to the prescaler and Reload values.
- *
- */
-IndependentWatchdog::IndependentWatchdog(IWDG_HandleTypeDef *watchdog) {
-	this->watchdog = watchdog;
+#define MAX_PR 			6
+#define RELOAD_LENGTH 	12
+#define WINDOW_LENGTH 	12
+#define LSI_SPEED 		32000
+#define PR_OFFSET		2
+#define MAX_TIMEOUT_MS		(((1 << RELOAD_LENGTH)*4*(1 << MAX_PR)*1000) / LSI_SPEED) // should be about 32768
+
+/*	A general watchdog, the window feature is not used
+	If it fails, no one could notice it, which is not really desired
+	@param: timeout - timeout in ms
+*/
+IndependentWatchdog::IndependentWatchdog(uint32_t timeout){
+	if (timeout >= MAX_TIMEOUT_MS) {
+		return;
+	}
+
+	if (counterCalculation(timeout, this->prescaler_, this->reload_) == false){
+		// Error_Handler();
+		return;
+	}
+	this->window_ = this->reload_;
+	this->watchdog_ = &hiwdg;
+
+	hiwdg.Instance = IWDG;
+	hiwdg.Init.Prescaler = this->prescaler_;
+	hiwdg.Init.Window = this->window_;
+	hiwdg.Init.Reload = this->reload_;
+	if (HAL_IWDG_Init(this->watchdog_) != HAL_OK)
+	{
+		Error_Handler();
+	}
+}
+
+/*	I don't know why STM added this feature, but you turn IWDG into a WWDG which is confusing
+	Now the watchdog triggers the reset when refresh comes too early or when downcounter reaches zero
+
+					|------- Refresh triggers reset -------- | ------- Refresh Allowed -------- |--- reset ---|
+					^                                        ^									^
+	counter value: reload                                  window                  				0
+
+	@param: counter_timeout - in ms
+	@param:	window_timeout  - in ms
+*/
+IndependentWatchdog::IndependentWatchdog(uint32_t counter_timeout, uint32_t window_timeout){
+	if (counter_timeout >= MAX_TIMEOUT_MS || window_timeout >= MAX_TIMEOUT_MS) {
+		return;
+	}
+
+	if (counterCalculation(counter_timeout, this->prescaler_, this->reload_) == false){
+		// Error_Handler();
+		return;
+	}
+	if (windowCalculation(window_timeout, this->prescaler_, this->window_) == false){
+		// Error_Handler();
+		return;
+	}
+	this->watchdog_ = &hiwdg;
+
+	hiwdg.Instance = IWDG;
+	hiwdg.Init.Prescaler = this->prescaler_;
+	hiwdg.Init.Window = this->window_;
+	hiwdg.Init.Reload = this->reload_;
+	if (HAL_IWDG_Init(this->watchdog_) != HAL_OK)
+	{
+		Error_Handler();
+	}
 }
 
 
@@ -15,10 +74,44 @@ IndependentWatchdog::IndependentWatchdog(IWDG_HandleTypeDef *watchdog) {
  * @brief Refreshes the watchdog that is a member variable of the class
  * @returns true on success, false on failure
  */
-
 bool IndependentWatchdog::refreshWatchdog() {
-	if (this->watchdog == nullptr) {
+	if (this->watchdog_ == nullptr) {
 		return false;
 	}
-	return (HAL_IWDG_Refresh(watchdog) == HAL_OK);
+	return (HAL_IWDG_Refresh(this->watchdog_) == HAL_OK);
+}
+
+
+/* 	Helper function
+	Updates the prescaler and reload depending on the timeout
+ */
+bool IndependentWatchdog::counterCalculation(uint32_t timeout, uint32_t &prescaler, uint32_t &counter){
+	int prescalerPR = 0; // start prescaler = 4
+	const uint32_t MAX_COUNTER = (1 << RELOAD_LENGTH);
+
+	for (; prescalerPR <= MAX_PR; prescalerPR++){
+		prescaler = prescalerPR;
+		uint32_t prescalerValue = 1 << (prescalerPR + PR_OFFSET);
+		counter = ((timeout * LSI_SPEED) / (prescalerValue * 1000)) - 1;
+		if (counter <=  MAX_COUNTER) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/* 	Helper function
+	Only update the window depending on the timeout
+*/
+bool IndependentWatchdog::windowCalculation(uint32_t timeout, uint32_t prescaler, uint32_t &window){
+	const uint32_t MAX_WINDOW = (1 << WINDOW_LENGTH);
+
+	uint32_t prescalerValue = 1 << (prescaler + PR_OFFSET);
+	window = ((timeout * LSI_SPEED) / (prescalerValue * 1000)) - 1;
+	if (window <=  MAX_WINDOW) {
+		return true;
+	}
+
+	return false;
 }

SystemManager/Src/SystemManager.cpp

@@ -12,7 +12,9 @@
 #include "sbus_receiver.hpp"
 #include "tim.h"
 
-#define TIMEOUT_CYCLES 250000  // 25k = 1 sec fro testing 10/14/2023 => 250k = 10 sec
+
+#define TIMEOUT_CYCLES 250000 // 25k = 1 sec fro testing 10/14/2023 => 250k = 10 sec
+#define TIMOUT_MS      10000 // 10 sec
 
 static uint32_t DisconnectionCount = 0;
 float prevthrottle;
@@ -27,7 +29,7 @@ SystemManager::SystemManager()
       rollMotorChannel_(&htim2, TIM_CHANNEL_3),
       pitchMotorChannel_(&htim2, TIM_CHANNEL_4),
       invertedRollMotorChannel_(&htim3, TIM_CHANNEL_1),
-      watchdog_(&hiwdg) {
+      watchdog_(TIMOUT_MS) {
     // VARIABLES FOR TELEMETRY MANAGER TO HAVE AS REFERENCES THEY OBV SHOULD BE PUT SOMEWHERE ELSE,
     // BUT I FEEL LIKE SM PM WOULD KNOW WHERE. MAYBE IN THE HPP FILE? IDK HOW YOU ARE PLANNING ON
     // GATHERING THE DATA. I JUST PUT THEM HERE FOR NOW
@@ -57,6 +59,7 @@ SystemManager::SystemManager()
     // REGULAR INTERVAL AS IT DEALS WITH MESSAGE DECODING AND LOW PRIORITY DATA TRANSMISSION
 }
 
+
 SystemManager::~SystemManager() {}
 
 void SystemManager::flyManually() {