nrf: watchdog: implement software watchdogtimer
This adds a software WatchDogTimer implementation that can be used for testing. Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross
parent
595f6387c2
commit
8f46133917
@ -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;
|
||||
|
||||
void common_hal_watchdog_init(uint32_t duration, bool pause_during_sleep) {
|
||||
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,
|
||||
};
|
||||
|
||||
|
||||
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"));
|
||||
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;
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
/*
|
||||
* 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>
|
||||
|
||||
#include "py/obj.h"
|
||||
#include "py/objproperty.h"
|
||||
#include "py/runtime.h"
|
||||
#include "shared-bindings/watchdog/__init__.h"
|
||||
#include "shared-bindings/watchdog/WatchDogTimer.h"
|
||||
|
||||
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 (args[ARG_timeout_ms].u_int <= 0) {
|
||||
// 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 (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;
|
||||
|
||||
common_hal_watchdog_init(self->timeout, self->sleep);
|
||||
wdt_singleton = self;
|
||||
return MP_OBJ_FROM_PTR(self);
|
||||
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,
|
||||
};
|
||||
|
||||
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);
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user