Skip to content

Commit 1220c31

Browse files
pennampennam
committed
Watchdog timer: add functions to configure timeout in ms
 * Fix return values * Check is initialized flag
1 parent cc5ca9e commit 1220c31

File tree

2 files changed

+203
-13
lines changed

2 files changed

+203
-13
lines changed

‎libraries/WDT/src/WDT.cpp

Lines changed: 123 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -19,27 +19,142 @@
1919

2020
#include "WDT.h"
2121

22-
WDTimer::WDTimer() { }
22+
WDTimer::WDTimer()
23+
: _is_initialized {false}
24+
, _p_ctrl {0}
25+
, _timeout {0}
26+
{
27+
28+
}
29+
2330
WDTimer::~WDTimer() { }
2431

2532
int WDTimer::begin(wdt_cfg_t config)
2633
{
27-
if(_is_initialized) {
28-
return FSP_SUCCESS;
34+
if (_is_initialized) {
35+
return 1;
2936
}
3037

3138
fsp_err_t err = R_WDT_Open(&_p_ctrl, &config);
32-
if(FSP_SUCCESS == err ) {
33-
R_WDT_Refresh(&_p_ctrl);
34-
_is_initialized = true;
39+
if (err != FSP_SUCCESS) {
40+
return 0;
3541
}
42+
R_WDT_Refresh(&_p_ctrl);
43+
_is_initialized = true;
3644

37-
return (int)err;
45+
return 1;
3846
}
3947

40-
void WDTimer::refresh()
48+
int WDTimer::begin(uint32_t timeout_ms)
4149
{
50+
if (_is_initialized) {
51+
return 1;
52+
}
53+
54+
const uint8_t pr = getPrescaler(timeout_ms);
55+
if (pr == WDT_INVALID_TIMEOUT) {
56+
return 0;
57+
}
58+
59+
const uint8_t rl = getReload(pr, timeout_ms);
60+
61+
wdt_cfg_t p_cfg;
62+
p_cfg.timeout = (wdt_timeout_t)rl;
63+
p_cfg.clock_division = (wdt_clock_division_t)pr;
64+
p_cfg.window_start = WDT_WINDOW_START_100;
65+
p_cfg.window_end = WDT_WINDOW_END_0;
66+
p_cfg.reset_control = WDT_RESET_CONTROL_RESET;
67+
p_cfg.stop_control = WDT_STOP_CONTROL_ENABLE;
68+
69+
fsp_err_t err = R_WDT_Open(&_p_ctrl, &p_cfg);
70+
if (err != FSP_SUCCESS) {
71+
return 0;
72+
}
73+
4274
R_WDT_Refresh(&_p_ctrl);
75+
_is_initialized = true;
76+
77+
return 1;
78+
}
79+
80+
void WDTimer::refresh()
81+
{
82+
if (_is_initialized) {
83+
R_WDT_Refresh(&_p_ctrl);
84+
}
85+
}
86+
87+
uint32_t WDTimer::getTimeout()
88+
{
89+
if (_is_initialized) {
90+
return _timeout;
91+
}
92+
return 0;
93+
}
94+
95+
uint32_t WDTimer::getCounter()
96+
{
97+
uint32_t count = 0;
98+
99+
if (_is_initialized) {
100+
R_WDT_CounterGet (&_p_ctrl, &count);
101+
}
102+
return count;
103+
}
104+
105+
uint32_t WDTimer::getTicksMs()
106+
{
107+
return (R_FSP_SystemClockHzGet(FSP_PRIV_CLOCK_PCLKB) / 1000);
108+
}
109+
110+
uint32_t WDTimer::getMaxTimeout()
111+
{
112+
return ((WDT_RL_VALUES::RL_16384 * WDT_PR_VALUES::PR_8192) / getTicksMs());
113+
}
114+
115+
uint32_t WDTimer::getPrescalerMaxTimeout(WDT_PR_VALUES pr)
116+
{
117+
return ((WDT_RL_VALUES::RL_16384 * pr) / getTicksMs());
118+
}
119+
120+
uint8_t WDTimer::getPrescaler(uint32_t timeout_ms)
121+
{
122+
const uint32_t max_timeout_ms = getMaxTimeout();
123+
124+
if (timeout_ms > max_timeout_ms) {
125+
return WDT_INVALID_TIMEOUT;
126+
}
127+
128+
uint32_t pr;
129+
for (pr = 0; pr < WDT_PR_ARRAY_SIZE; pr++) {
130+
if (!prescaler_values[pr]) {
131+
break;
132+
}
133+
134+
const uint32_t pr_max_timeout_ms = getPrescalerMaxTimeout(prescaler_values[pr]);
135+
if (timeout_ms <= pr_max_timeout_ms) {
136+
break;
137+
}
138+
}
139+
140+
const uint32_t pr_max_timeout_ms = getPrescalerMaxTimeout(WDT_PR_VALUES::PR_128);
141+
if (pr > WDT_CLOCK_DIVISION_64 && timeout_ms <= pr_max_timeout_ms) {
142+
return WDT_CLOCK_DIVISION_128;
143+
}
144+
return pr;
145+
}
146+
147+
uint8_t WDTimer::getReload(uint8_t pr, uint32_t timeout_ms)
148+
{
149+
uint32_t rl;
150+
for (rl = 0; rl < WDT_RL_ARRAY_SIZE; rl++) {
151+
const uint32_t pr_max_timeout_ms = (reload_values[rl] * prescaler_values[pr]) / (getTicksMs());
152+
if (timeout_ms <= pr_max_timeout_ms) {
153+
_timeout = pr_max_timeout_ms;
154+
return rl;
155+
}
156+
}
157+
return rl;
43158
}
44159

45160
WDTimer WDT;

‎libraries/WDT/src/WDT.h

Lines changed: 80 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -22,18 +22,93 @@
2222

2323
#include "r_wdt.h"
2424

25-
class WDTimer {
26-
private:
27-
bool _is_initialized;
28-
wdt_instance_ctrl_t _p_ctrl;
25+
#define WDT_INVALID_TIMEOUT 255
26+
#define WDT_PR_ARRAY_SIZE 16
27+
#define WDT_RL_ARRAY_SIZE 7
2928

29+
class WDTimer {
3030
public:
3131
WDTimer();
3232
~WDTimer();
3333

3434
int begin(wdt_cfg_t config);
35-
35+
int begin(uint32_t timeout_ms);
3636
void refresh();
37+
uint32_t getTimeout();
38+
uint32_t getCounter();
39+
40+
private:
41+
bool _is_initialized;
42+
wdt_instance_ctrl_t _p_ctrl;
43+
uint32_t _timeout;
44+
45+
/* WDT prescaler values */
46+
enum WDT_PR_VALUES
47+
{
48+
PR_INVALID = 0,
49+
PR_1 = 1,
50+
PR_4 = 4,
51+
PR_16 = 16,
52+
PR_32 = 32,
53+
PR_64 = 64,
54+
PR_128 = 128,
55+
PR_256 = 256,
56+
PR_512 = 512,
57+
PR_2048 = 2048,
58+
PR_8192 = 8192,
59+
};
60+
61+
/* WDT reload values */
62+
enum WDT_RL_VALUES
63+
{
64+
RL_128 = 128,
65+
RL_512 = 512,
66+
RL_1024 = 1024,
67+
RL_2048 = 2048,
68+
RL_4096 = 4096,
69+
RL_8192 = 8192,
70+
RL_16384 = 16384,
71+
};
72+
73+
/* Maps to WDT clock division ratio. e_wdt_clock_division */
74+
const WDT_PR_VALUES prescaler_values[WDT_PR_ARRAY_SIZE] =
75+
{
76+
WDT_PR_VALUES::PR_1,
77+
WDT_PR_VALUES::PR_4,
78+
WDT_PR_VALUES::PR_16,
79+
WDT_PR_VALUES::PR_32,
80+
WDT_PR_VALUES::PR_64,
81+
WDT_PR_VALUES::PR_256,
82+
WDT_PR_VALUES::PR_512,
83+
WDT_PR_VALUES::PR_2048,
84+
WDT_PR_VALUES::PR_8192,
85+
WDT_PR_VALUES::PR_INVALID,
86+
WDT_PR_VALUES::PR_INVALID,
87+
WDT_PR_VALUES::PR_INVALID,
88+
WDT_PR_VALUES::PR_INVALID,
89+
WDT_PR_VALUES::PR_INVALID,
90+
WDT_PR_VALUES::PR_INVALID,
91+
WDT_PR_VALUES::PR_128
92+
};
93+
94+
/* Maps to WDT time-out periods. e_wdt_timeout */
95+
const WDT_RL_VALUES reload_values[WDT_RL_ARRAY_SIZE] =
96+
{
97+
WDT_RL_VALUES::RL_128,
98+
WDT_RL_VALUES::RL_512,
99+
WDT_RL_VALUES::RL_1024,
100+
WDT_RL_VALUES::RL_2048,
101+
WDT_RL_VALUES::RL_4096,
102+
WDT_RL_VALUES::RL_8192,
103+
WDT_RL_VALUES::RL_16384
104+
};
105+
106+
uint32_t getTicksMs();
107+
uint32_t getMaxTimeout();
108+
uint32_t getPrescalerMaxTimeout(WDT_PR_VALUES pr);
109+
uint8_t getPrescaler(uint32_t timeout_ms);
110+
uint8_t getReload(uint8_t pr, uint32_t timeout_ms);
111+
37112
};
38113

39114
extern WDTimer WDT;

0 commit comments

Comments
 (0)