summaryrefslogtreecommitdiff
path: root/ports
diff options
context:
space:
mode:
Diffstat (limited to 'ports')
-rw-r--r--ports/nrf/common-hal/watchdog/WatchDogTimer.c223
-rw-r--r--ports/nrf/common-hal/watchdog/WatchDogTimer.h3
2 files changed, 166 insertions, 60 deletions
diff --git a/ports/nrf/common-hal/watchdog/WatchDogTimer.c b/ports/nrf/common-hal/watchdog/WatchDogTimer.c
index 8213f9176..300ac7712 100644
--- a/ports/nrf/common-hal/watchdog/WatchDogTimer.c
+++ b/ports/nrf/common-hal/watchdog/WatchDogTimer.c
@@ -24,15 +24,47 @@
* THE SOFTWARE.
*/
+
+#include <math.h>
+#include <string.h>
+
#include "py/obj.h"
+#include "py/objproperty.h"
#include "py/runtime.h"
#include "common-hal/watchdog/WatchDogTimer.h"
+
+#include "shared-bindings/watchdog/__init__.h"
+#include "shared-bindings/watchdog/WatchDogTimer.h"
+
#include "nrf_wdt.h"
+#include "nrfx_timer.h"
+#include "nrf/timers.h"
+STATIC watchdog_watchdogtimer_obj_t *wdt_singleton;
+STATIC mp_obj_t watchdog_watchdogtimer_feed(mp_obj_t self_in);
+STATIC uint8_t timer_refcount = 0;
#define WATCHDOG_RELOAD_COUNT 2
+STATIC nrfx_timer_t *timer = NULL;
+
+const mp_obj_type_t mp_type_WatchDogTimeout = {
+ { &mp_type_type },
+ .name = MP_QSTR_WatchDogTimeout,
+ .make_new = mp_obj_exception_make_new,
+ .attr = mp_obj_exception_attr,
+ .parent = &mp_type_Exception,
+};
+
+static mp_obj_exception_t mp_watchdog_timeout_exception = {
+ .base.type = &mp_type_WatchDogTimeout,
+ .traceback_alloc = 0,
+ .traceback_len = 0,
+ .traceback_data = NULL,
+ .args = (mp_obj_tuple_t*)&mp_const_empty_tuple_obj,
+};
-void common_hal_watchdog_init(uint32_t duration, bool pause_during_sleep) {
+
+STATIC void watchdogtimer_hardware_init(mp_float_t duration, bool pause_during_sleep) {
unsigned int channel;
nrf_wdt_behaviour_t behaviour = NRF_WDT_BEHAVIOUR_RUN_SLEEP_HALT;
if (pause_during_sleep) {
@@ -41,7 +73,7 @@ void common_hal_watchdog_init(uint32_t duration, bool pause_during_sleep) {
nrf_wdt_behaviour_set(NRF_WDT, behaviour);
- uint64_t ticks = (duration * 32768ULL) / 1000;
+ uint64_t ticks = duration * 32768ULL;
if (ticks > UINT32_MAX) {
mp_raise_ValueError(translate("timeout duration exceeded the maximum supported value"));
}
@@ -54,52 +86,38 @@ void common_hal_watchdog_init(uint32_t duration, bool pause_during_sleep) {
nrf_wdt_task_trigger(NRF_WDT, NRF_WDT_TASK_START);
}
-void common_hal_watchdog_feed(void) {
+STATIC void watchdogtimer_hardware_feed(void) {
unsigned int channel;
for (channel = 0; channel < WATCHDOG_RELOAD_COUNT; channel++) {
nrf_wdt_reload_request_set(NRF_WDT, (nrf_wdt_rr_register_t)(NRF_WDT_RR0 + channel));
}
}
-void common_hal_watchdog_disable(void) {
- // mp_raise_ValueError(translate("Watchdog timer cannot be disabled -- board will reset shortly"));
-}
-
-/*
- * This file is part of the MicroPython project, http://micropython.org/
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2016 Paul Sokolovsky
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include <string.h>
+STATIC void watchdogtimer_event_handler(nrf_timer_event_t event_type, void *p_context) {
+ (void)p_context;
+ if (event_type != NRF_TIMER_EVENT_COMPARE0) {
+ // Spurious event.
+ return;
+ }
-#include "py/obj.h"
-#include "py/objproperty.h"
-#include "py/runtime.h"
-#include "shared-bindings/watchdog/__init__.h"
-#include "shared-bindings/watchdog/WatchDogTimer.h"
+ // If the timer hits without being cleared, pause the timer and raise an exception.
+ nrfx_timer_pause(timer);
+ mp_obj_exception_clear_traceback(MP_OBJ_FROM_PTR(&mp_watchdog_timeout_exception));
+ MP_STATE_VM(mp_pending_exception) = &mp_watchdog_timeout_exception;
+#if MICROPY_ENABLE_SCHEDULER
+ if (MP_STATE_VM(sched_state) == MP_SCHED_IDLE) {
+ MP_STATE_VM(sched_state) = MP_SCHED_PENDING;
+ }
+#endif
+}
-static watchdog_watchdogtimer_obj_t *wdt_singleton;
+void watchdog_watchdogtimer_reset(void) {
+ if (timer != NULL) {
+ nrf_peripherals_free_timer(timer);
+ }
+ timer = NULL;
+ timer_refcount = 0;
+}
//| class WDT:
//| """Watchdog Timer"""
@@ -114,31 +132,79 @@ static watchdog_watchdogtimer_obj_t *wdt_singleton;
STATIC mp_obj_t watchdog_watchdogtimer_make_new(const mp_obj_type_t *type, size_t n_args,
const mp_obj_t *pos_args,
mp_map_t *kw_args) {
- enum { ARG_timeout_ms, ARG_sleep };
+ enum { ARG_timeout, ARG_sleep, ARG_hardware };
static const mp_arg_t allowed_args[] = {
- {MP_QSTR_timeout_ms, MP_ARG_INT | MP_ARG_REQUIRED},
+ {MP_QSTR_timeout, MP_ARG_OBJ | MP_ARG_REQUIRED},
{MP_QSTR_sleep, MP_ARG_BOOL, {.u_bool = false}},
+ {MP_QSTR_hardware, MP_ARG_BOOL, {.u_bool = false}},
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
- if (wdt_singleton)
- return wdt_singleton;
-
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args),
allowed_args, args);
+ mp_float_t timeout = mp_obj_get_float(args[ARG_timeout].u_obj);
+ bool hardware = args[ARG_hardware].u_bool;
+ bool sleep = args[ARG_sleep].u_bool;
+
+ // If the hardware timer is already running, return that timer.
+ // If the parameters have changed, then ignore them, but print
+ // an error.
+ if (wdt_singleton && hardware) {
+ if ((sleep != wdt_singleton->sleep)
+ || (hardware != wdt_singleton->hardware)
+ || fabsf(timeout - wdt_singleton->timeout) > 0.01f) {
+ // Print a warning indicating things aren't quite right
+ // mp_printf(&mp_stderr_print, translate("warning: hardware timer was already running"));
+ }
+ watchdogtimer_hardware_feed();
+ return wdt_singleton;
+ }
- if (args[ARG_timeout_ms].u_int <= 0) {
+ if (timeout <= 0) {
mp_raise_ValueError(translate("watchdog timeout must be greater than 0"));
}
watchdog_watchdogtimer_obj_t *self = m_new_obj(watchdog_watchdogtimer_obj_t);
self->base.type = &watchdog_watchdogtimer_type;
- self->timeout = args[ARG_timeout_ms].u_int;
- self->sleep = args[ARG_sleep].u_bool;
+ self->timeout = timeout;
+ self->sleep = sleep;
+ self->hardware = hardware;
+
+ if (hardware) {
+ watchdogtimer_hardware_init(self->timeout, self->sleep);
+ wdt_singleton = self;
+ } else {
+ uint64_t ticks = timeout * 31250ULL;
+ if (ticks > UINT32_MAX) {
+ mp_raise_ValueError(translate("timeout duration exceeded the maximum supported value"));
+ }
+
+ if (timer_refcount == 0) {
+ timer = nrf_peripherals_allocate_timer_or_throw();
+ }
+ timer_refcount++;
+
+ nrfx_timer_config_t timer_config = {
+ .frequency = NRF_TIMER_FREQ_31250Hz,
+ .mode = NRF_TIMER_MODE_TIMER,
+ .bit_width = NRF_TIMER_BIT_WIDTH_32,
+ .interrupt_priority = NRFX_TIMER_DEFAULT_CONFIG_IRQ_PRIORITY,
+ .p_context = self,
+ };
- common_hal_watchdog_init(self->timeout, self->sleep);
- wdt_singleton = self;
- return MP_OBJ_FROM_PTR(self);
+ nrfx_timer_init(timer, &timer_config, &watchdogtimer_event_handler);
+
+ // true enables interrupt.
+ nrfx_timer_clear(timer);
+ nrfx_timer_compare(timer, NRF_TIMER_CC_CHANNEL0, ticks, true);
+ nrfx_timer_resume(timer);
+ }
+
+ // Feed the watchdog, in case there's a timer that's already running
+ // and it's only partially finished.
+ mp_obj_t *self_obj = MP_OBJ_FROM_PTR(self);
+ watchdog_watchdogtimer_feed(self_obj);
+ return self_obj;
}
//| def feed(self):
@@ -147,8 +213,13 @@ STATIC mp_obj_t watchdog_watchdogtimer_make_new(const mp_obj_type_t *type, size_
//| ...
//|
STATIC mp_obj_t watchdog_watchdogtimer_feed(mp_obj_t self_in) {
- (void)self_in;
- common_hal_watchdog_feed();
+ watchdog_watchdogtimer_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+ if (self->hardware) {
+ watchdogtimer_hardware_feed();
+ } else {
+ nrfx_timer_clear(timer);
+ }
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(watchdog_watchdogtimer_feed_obj, watchdog_watchdogtimer_feed);
@@ -159,8 +230,16 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(watchdog_watchdogtimer_feed_obj, watchdog_watch
//| ...
//|
STATIC mp_obj_t watchdog_watchdogtimer_deinit(mp_obj_t self_in) {
- (void)self_in;
- common_hal_watchdog_disable();
+ watchdog_watchdogtimer_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+ if (!self->hardware) {
+ timer_refcount--;
+ if (timer_refcount == 0) {
+ nrf_peripherals_free_timer(timer);
+ timer = NULL;
+ }
+ }
+
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(watchdog_watchdogtimer_deinit_obj, watchdog_watchdogtimer_deinit);
@@ -169,23 +248,49 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(watchdog_watchdogtimer_deinit_obj, watchdog_wat
//| """The maximum number of milliseconds that can elapse between calls
//| to feed()"""
//|
-STATIC mp_obj_t watchdog_watchdogtimer_obj_get_timeout(mp_obj_t self_in) {
+STATIC mp_obj_t watchdog_watchdogtimer_get_timeout(mp_obj_t self_in) {
watchdog_watchdogtimer_obj_t *self = MP_OBJ_TO_PTR(self_in);
- return mp_obj_new_int(self->timeout);
+ return mp_obj_new_float(self->timeout);
}
-MP_DEFINE_CONST_FUN_OBJ_1(watchdog_watchdogtimer_obj_get_timeout_obj, watchdog_watchdogtimer_obj_get_timeout);
+MP_DEFINE_CONST_FUN_OBJ_1(watchdog_watchdogtimer_get_timeout_obj, watchdog_watchdogtimer_get_timeout);
const mp_obj_property_t watchdog_watchdogtimer_timeout_obj = {
.base.type = &mp_type_property,
- .proxy = {(mp_obj_t)&watchdog_watchdogtimer_obj_get_timeout_obj,
+ .proxy = {(mp_obj_t)&watchdog_watchdogtimer_get_timeout_obj,
(mp_obj_t)&mp_const_none_obj,
(mp_obj_t)&mp_const_none_obj},
};
+mp_obj_t watchdog_watchdogtimer___enter__(mp_obj_t self_in) {
+ watchdog_watchdogtimer_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+ if (!self->hardware) {
+ nrfx_timer_resume(timer);
+ }
+ watchdog_watchdogtimer_feed(self_in);
+ return self_in;
+}
+MP_DEFINE_CONST_FUN_OBJ_1(watchdog_watchdogtimer___enter___obj, watchdog_watchdogtimer___enter__);
+
+STATIC mp_obj_t watchdog_watchdogtimer___exit__(size_t n_args, const mp_obj_t *args) {
+ (void)n_args;
+ watchdog_watchdogtimer_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+ if (!self->hardware) {
+ if (timer) {
+ nrfx_timer_pause(timer);
+ }
+ }
+ return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(watchdog_watchdogtimer___exit___obj, 4, 4, watchdog_watchdogtimer___exit__);
+
STATIC const mp_rom_map_elem_t watchdog_watchdogtimer_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_feed), MP_ROM_PTR(&watchdog_watchdogtimer_feed_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&watchdog_watchdogtimer_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_timeout), MP_ROM_PTR(&watchdog_watchdogtimer_timeout_obj) },
+ // { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
+ { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&watchdog_watchdogtimer___enter___obj) },
+ { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&watchdog_watchdogtimer___exit___obj) },
};
STATIC MP_DEFINE_CONST_DICT(watchdog_watchdogtimer_locals_dict, watchdog_watchdogtimer_locals_dict_table);
diff --git a/ports/nrf/common-hal/watchdog/WatchDogTimer.h b/ports/nrf/common-hal/watchdog/WatchDogTimer.h
index ca57cf8a4..c59796820 100644
--- a/ports/nrf/common-hal/watchdog/WatchDogTimer.h
+++ b/ports/nrf/common-hal/watchdog/WatchDogTimer.h
@@ -32,8 +32,9 @@
typedef struct _watchdog_watchdogtimer_obj_t {
mp_obj_base_t base;
- uint32_t timeout;
+ mp_float_t timeout;
bool sleep;
+ bool hardware;
} watchdog_watchdogtimer_obj_t;
#endif // MICROPY_INCLUDED_NRF_COMMON_HAL_WATCHDOG_WATCHDOGTIMER_H
generated by cgit v1.2.3 (git 2.39.1) at 2026-08-08 10:27:49 +0000