djsundog
/
circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

watchdogtimer: refactor to new api 

This refactors the WatchDogTimer API to use the format proposed in
https://github.com/adafruit/circuitpython/pull/2933#issuecomment-632268227

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-05-22 12:35:29 +08:00
parent ec99dae953
commit 08362c9cab
13 changed files with 307 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ports/nrf/common-hal/microcontroller/__init__.c
View File

@ -117,12 +117,14 @@ const nvm_bytearray_obj_t common_hal_mcu_nvm_obj = {
#endif
#if CIRCUITPY_WATCHDOG
// The singleton nvm.WatchDogTimer object.
const watchdog_obj_t common_hal_mcu_watchdog_obj = {
// The singleton watchdog.WatchDogTimer object.
watchdog_watchdogtimer_obj_t common_hal_mcu_watchdogtimer_obj = {
.base = {
.type = &watchdog_type,
.type = &watchdog_watchdogtimer_type,
},
.watchdogtimer = (mp_obj_t)&mp_const_none_obj,
.timeout = 0.0f,
.sleep = false,
.mode = WATCHDOGMODE_NONE,
};
#endif

0
ports/nrf/common-hal/watchdog/WatchDogMode.c Normal file
View File

264
ports/nrf/common-hal/watchdog/WatchDogTimer.c
View File

@ -41,8 +41,6 @@
#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;
@ -80,7 +78,7 @@ NORETURN void mp_raise_WatchDogTimeout(void) {
nlr_raise(MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_watchdog_exception)));
}
STATIC void watchdogtimer_event_handler(nrf_timer_event_t event_type, void *p_context) {
STATIC void watchdogtimer_timer_event_handler(nrf_timer_event_t event_type, void *p_context) {
(void)p_context;
if (event_type != NRF_TIMER_EVENT_COMPARE0) {
// Spurious event.
@ -105,66 +103,145 @@ void watchdog_watchdogtimer_reset(void) {
timer_refcount = 0;
}
//| class WDT:
//| """Watchdog Timer"""
//|
//| def __init__(self, ):
//| """This class represents the system's Watchdog Timer. It is a
//| singleton and will always return the same instance.
//|
//| """
//| def feed(self):
//| """Feed the watchdog timer. This must be called regularly, otherwise
//| the timer will expire."""
//| ...
//|
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, ARG_sleep, ARG_hardware };
static const mp_arg_t allowed_args[] = {
{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)];
mp_obj_exception_clear_traceback(MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_watchdog_exception)));
STATIC mp_obj_t watchdog_watchdogtimer_feed(mp_obj_t self_in) {
watchdog_watchdogtimer_obj_t *self = MP_OBJ_TO_PTR(self_in);
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"));
}
if (self->mode == WATCHDOGMODE_RESET) {
watchdogtimer_hardware_feed();
return wdt_singleton;
} else if (self->mode == WATCHDOGMODE_RAISE) {
nrfx_timer_clear(timer);
} else if (self->mode == WATCHDOGMODE_NONE) {
mp_raise_ValueError(translate("WatchDogTimer is not currently running"));
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(watchdog_watchdogtimer_feed_obj, watchdog_watchdogtimer_feed);
//| def deinit(self):
//| """Stop the watchdog timer. This may raise an error if the watchdog
//| timer cannot be disabled on this platform."""
//| ...
//|
STATIC mp_obj_t watchdog_watchdogtimer_deinit(mp_obj_t self_in) {
watchdog_watchdogtimer_obj_t *self = MP_OBJ_TO_PTR(self_in);
if (self->mode == WATCHDOGMODE_RAISE) {
timer_refcount--;
if (timer_refcount == 0) {
nrf_peripherals_free_timer(timer);
timer = NULL;
}
} else if (self->mode == WATCHDOGMODE_RESET) {
mp_raise_NotImplementedError(translate("WatchDogTimer cannot be deinitialized once mode is set to RESET"));
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(watchdog_watchdogtimer_deinit_obj, watchdog_watchdogtimer_deinit);
//| timeout: float = ...
//| """The maximum number of seconds that can elapse between calls
//| to feed()"""
//|
STATIC mp_obj_t watchdog_watchdogtimer_obj_get_timeout(mp_obj_t self_in) {
watchdog_watchdogtimer_obj_t *self = MP_OBJ_TO_PTR(self_in);
return mp_obj_new_float(self->timeout);
}
MP_DEFINE_CONST_FUN_OBJ_1(watchdog_watchdogtimer_get_timeout_obj, watchdog_watchdogtimer_obj_get_timeout);
STATIC mp_obj_t watchdog_watchdogtimer_obj_set_timeout(mp_obj_t self_in, mp_obj_t timeout_obj) {
watchdog_watchdogtimer_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_float_t timeout = mp_obj_get_float(timeout_obj);
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 = timeout;
self->sleep = sleep;
self->hardware = hardware;
if (hardware) {
watchdogtimer_hardware_init(self->timeout, self->sleep);
wdt_singleton = self;
} else {
if (self->mode == WATCHDOGMODE_RESET) {
// If the WatchDogTimer is already running in "RESET" mode, raise an error
// since the mode cannot be changed once started.
mp_raise_TypeError(translate("Cannot change the timeout once mode is WatchDogMode.RESET"));
} else if (self->mode == WATCHDOGMODE_RAISE) {
// If the WatchDogTimer is already running in "RAISE" mode, reset the timer
// with the new value.
uint64_t ticks = timeout * 31250ULL;
if (ticks > UINT32_MAX) {
mp_raise_ValueError(translate("timeout duration exceeded the maximum supported value"));
}
nrfx_timer_clear(timer);
nrfx_timer_compare(timer, NRF_TIMER_CC_CHANNEL0, ticks, true);
}
self->timeout = timeout;
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(watchdog_watchdogtimer_set_timeout_obj, watchdog_watchdogtimer_obj_set_timeout);
const mp_obj_property_t watchdog_watchdogtimer_timeout_obj = {
.base.type = &mp_type_property,
.proxy = {(mp_obj_t)&watchdog_watchdogtimer_get_timeout_obj,
(mp_obj_t)&watchdog_watchdogtimer_set_timeout_obj,
(mp_obj_t)&mp_const_none_obj},
};
//| mode: watchdog.WatchDogMode = ...
//| """The current operating mode of the WatchDogTimer `watchdog.WatchDogMode`.
//|
//| Setting a WatchDogMode activates the WatchDog::
//|
//| import microcontroller
//| import watchdog
//|
//| w = microcontroller.watchdog
//| w.timeout = 5
//| w.mode = watchdog.WatchDogMode.RAISE
//|
//|
//| Once set, the WatchDogTimer will perform the specified action if the timer expires.
//|
STATIC mp_obj_t watchdog_watchdogtimer_obj_get_mode(mp_obj_t self_in) {
watchdog_watchdogtimer_obj_t *self = MP_OBJ_TO_PTR(self_in);
switch (self->mode) {
case WATCHDOGMODE_NONE: default: return (mp_obj_t)MP_ROM_PTR(&watchdog_watchdogmode_none_obj);
case WATCHDOGMODE_RAISE: return (mp_obj_t)MP_ROM_PTR(&watchdog_watchdogmode_raise_obj);
case WATCHDOGMODE_RESET: return (mp_obj_t)MP_ROM_PTR(&watchdog_watchdogmode_reset_obj);
}
}
MP_DEFINE_CONST_FUN_OBJ_1(watchdog_watchdogtimer_get_mode_obj, watchdog_watchdogtimer_obj_get_mode);
STATIC mp_obj_t watchdog_watchdogtimer_obj_set_mode(mp_obj_t self_in, mp_obj_t mode_obj) {
watchdog_watchdogtimer_obj_t *self = MP_OBJ_TO_PTR(self_in);
watchdog_watchdogmode_obj_t *mode = MP_OBJ_TO_PTR(mode_obj);
if (mode == MP_ROM_PTR(&watchdog_watchdogmode_none_obj)) {
if (self->mode == WATCHDOGMODE_RESET) {
mp_raise_TypeError(translate("WatchDogTimer mode cannot be changed once set to WatchDogMode.RESET"));
}
else if (self->mode == WATCHDOGMODE_RAISE) {
timer_refcount--;
if (timer_refcount == 0) {
nrf_peripherals_free_timer(timer);
timer = NULL;
}
}
self->mode = WATCHDOGMODE_NONE;
} else if (mode == MP_ROM_PTR(&watchdog_watchdogmode_raise_obj)) {
if (self->timeout <= 0) {
mp_raise_ValueError(translate("watchdog timeout must be greater than 0"));
}
if (self->mode == WATCHDOGMODE_RESET) {
mp_raise_ValueError(translate("WatchDogTimer mode cannot be changed once set to WatchDogMode.RESET"));
}
else if (self->mode == WATCHDOGMODE_NONE) {
uint64_t ticks = self->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();
@ -179,111 +256,52 @@ STATIC mp_obj_t watchdog_watchdogtimer_make_new(const mp_obj_type_t *type, size_
.p_context = self,
};
nrfx_timer_init(timer, &timer_config, &watchdogtimer_event_handler);
nrfx_timer_init(timer, &timer_config, &watchdogtimer_timer_event_handler);
// true enables interrupt.
nrfx_timer_clear(timer);
nrfx_timer_compare(timer, NRF_TIMER_CC_CHANNEL0, ticks, true);
nrfx_timer_resume(timer);
}
self->mode = WATCHDOGMODE_RAISE;
// 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):
//| """Feed the watchdog timer. This must be called regularly, otherwise
//| the system will reset."""
//| ...
//|
STATIC mp_obj_t watchdog_watchdogtimer_feed(mp_obj_t self_in) {
watchdog_watchdogtimer_obj_t *self = MP_OBJ_TO_PTR(self_in);
if (self->hardware) {
watchdogtimer_hardware_feed();
} else {
nrfx_timer_clear(timer);
} else if (mode == MP_ROM_PTR(&watchdog_watchdogmode_reset_obj)) {
if (self->timeout <= 0) {
mp_raise_ValueError(translate("watchdog timeout must be greater than 0"));
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(watchdog_watchdogtimer_feed_obj, watchdog_watchdogtimer_feed);
//| def deinit(self):
//| """Stop the watchdog timer. This may raise an error if the watchdog
//| timer cannot be disabled on this platform."""
//| ...
//|
STATIC mp_obj_t watchdog_watchdogtimer_deinit(mp_obj_t self_in) {
watchdog_watchdogtimer_obj_t *self = MP_OBJ_TO_PTR(self_in);
if (!self->hardware) {
if (self->mode == WATCHDOGMODE_RAISE) {
timer_refcount--;
if (timer_refcount == 0) {
nrf_peripherals_free_timer(timer);
timer = NULL;
}
}
watchdogtimer_hardware_init(self->timeout, self->sleep);
self->mode = WATCHDOGMODE_RESET;
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(watchdog_watchdogtimer_deinit_obj, watchdog_watchdogtimer_deinit);
MP_DEFINE_CONST_FUN_OBJ_2(watchdog_watchdogtimer_set_mode_obj, watchdog_watchdogtimer_obj_set_mode);
//| timeout: int = ...
//| """The maximum number of milliseconds that can elapse between calls
//| to feed()"""
//|
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_float(self->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 = {
const mp_obj_property_t watchdog_watchdogtimer_mode_obj = {
.base.type = &mp_type_property,
.proxy = {(mp_obj_t)&watchdog_watchdogtimer_get_timeout_obj,
(mp_obj_t)&mp_const_none_obj,
.proxy = {(mp_obj_t)&watchdog_watchdogtimer_get_mode_obj,
(mp_obj_t)&watchdog_watchdogtimer_set_mode_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) },
{ MP_ROM_QSTR(MP_QSTR_mode), MP_ROM_PTR(&watchdog_watchdogtimer_mode_obj) },
};
STATIC MP_DEFINE_CONST_DICT(watchdog_watchdogtimer_locals_dict, watchdog_watchdogtimer_locals_dict_table);
const mp_obj_type_t watchdog_watchdogtimer_type = {
{ &mp_type_type },
.name = MP_QSTR_WatchDogTimer,
.make_new = watchdog_watchdogtimer_make_new,
// .make_new = watchdog_watchdogtimer_make_new,
.locals_dict = (mp_obj_dict_t*)&watchdog_watchdogtimer_locals_dict,
};

3
ports/nrf/common-hal/watchdog/WatchDogTimer.h
View File

@ -29,12 +29,13 @@
#include "py/obj.h"
#include "shared-bindings/watchdog/WatchDogTimer.h"
#include "shared-bindings/watchdog/WatchDogMode.h"
typedef struct _watchdog_watchdogtimer_obj_t {
mp_obj_base_t base;
mp_float_t timeout;
bool sleep;
bool hardware;
watchdog_watchdogmode_t mode;
} watchdog_watchdogtimer_obj_t;
#endif // MICROPY_INCLUDED_NRF_COMMON_HAL_WATCHDOG_WATCHDOGTIMER_H

17
ports/nrf/common-hal/watchdog/__init__.c
View File

@ -23,20 +23,3 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "py/obj.h"
#include "common-hal/watchdog/__init__.h"
#include "common-hal/watchdog/WatchDogTimer.h"
STATIC const mp_rom_map_elem_t watchdog_locals_dict_table[] = {
{MP_ROM_QSTR(MP_QSTR_WatchDogTimer), MP_ROM_PTR(&watchdog_watchdogtimer_type) },
};
STATIC MP_DEFINE_CONST_DICT(watchdog_locals_dict, watchdog_locals_dict_table);
const mp_obj_type_t watchdog_type = {
{ &mp_type_type },
.name = MP_QSTR_watchdog,
// .make_new = watchdog_watchdogtimer_make_new,
.locals_dict = (mp_obj_dict_t*)&watchdog_locals_dict,
};

1
py/circuitpy_defns.mk
View File

@ -306,6 +306,7 @@ SRC_COMMON_HAL_ALL = \
supervisor/Runtime.c \
supervisor/__init__.c \
watchdog/__init__.c \
watchdog/WatchDogMode.c \
watchdog/WatchDogTimer.c \
SRC_COMMON_HAL = $(filter $(SRC_PATTERNS), $(SRC_COMMON_HAL_ALL))

4
py/circuitpy_mpconfig.h
View File

@ -633,6 +633,9 @@ extern const struct _mp_obj_module_t ustack_module;
// This is not a top-level module; it's microcontroller.watchdog.
#if CIRCUITPY_WATCHDOG
extern const struct _mp_obj_module_t watchdog_module;
#define WATCHDOG_MODULE { MP_ROM_QSTR(MP_QSTR_watchdog), MP_ROM_PTR(&watchdog_module) },
#else
#define WATCHDOG_MODULE
#endif
// Define certain native modules with weak links so they can be replaced with Python
@ -705,6 +708,7 @@ extern const struct _mp_obj_module_t watchdog_module;
USB_HID_MODULE \
USB_MIDI_MODULE \
USTACK_MODULE \
WATCHDOG_MODULE \
// If weak links are enabled, just include strong links in the main list of modules,
// and also include the underscore alternate names.

2
shared-bindings/microcontroller/__init__.c
View File

@ -168,7 +168,7 @@ STATIC const mp_rom_map_elem_t mcu_module_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR_nvm), MP_ROM_PTR(&mp_const_none_obj) },
#endif
#if CIRCUITPY_WATCHDOG
{ MP_ROM_QSTR(MP_QSTR_watchdog), MP_ROM_PTR(&common_hal_mcu_watchdog_obj) },
{ MP_ROM_QSTR(MP_QSTR_watchdog), MP_ROM_PTR(&common_hal_mcu_watchdogtimer_obj) },
#else
{ MP_ROM_QSTR(MP_QSTR_watchdog), MP_ROM_PTR(&mp_const_none_obj) },
#endif

4
shared-bindings/microcontroller/__init__.h
View File

@ -54,8 +54,8 @@ extern const nvm_bytearray_obj_t common_hal_mcu_nvm_obj;
#endif
#if CIRCUITPY_WATCHDOG
#include "common-hal/watchdog/__init__.h"
extern const watchdog_obj_t common_hal_mcu_watchdog_obj;
#include "common-hal/watchdog/WatchDogTimer.h"
extern watchdog_watchdogtimer_obj_t common_hal_mcu_watchdogtimer_obj;
#endif
#endif // MICROPY_INCLUDED_SHARED_BINDINGS_MICROCONTROLLER___INIT___H

88
shared-bindings/watchdog/WatchDogMode.c Normal file
View File

@ -0,0 +1,88 @@
/*
* This file is part of the Micro Python project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2020 Sean Cross for Adafruit Industries
*
* 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 "shared-bindings/watchdog/WatchDogMode.h"
//| class WatchDogMode:
//| """run state of the watchdog timer"""
//|
//| def __init__(self, ):
//| """Enum-like class to define the run mode of the watchdog timer."""
//|
//| NONE: Any = ...
//| """Take no action if the watchdog timer expires.
//|
//| :type watchdog.WatchDogMode:"""
//|
//| RAISE: Any = ...
//| """Raise an exception when the WatchDogTimer expires.
//|
//| :type watchdog.WatchDogMode:"""
//|
//| RESET: Any = ...
//| """Reset the system if the WatchDogTimer expires.
//|
//| :type watchdog.WatchDogMode:"""
//|
const mp_obj_type_t watchdog_watchdogmode_type;
const watchdog_watchdogmode_obj_t watchdog_watchdogmode_none_obj = {
{ &watchdog_watchdogmode_type },
};
const watchdog_watchdogmode_obj_t watchdog_watchdogmode_raise_obj = {
{ &watchdog_watchdogmode_type },
};
const watchdog_watchdogmode_obj_t watchdog_watchdogmode_reset_obj = {
{ &watchdog_watchdogmode_type },
};
STATIC const mp_rom_map_elem_t watchdog_watchdogmode_locals_dict_table[] = {
{MP_ROM_QSTR(MP_QSTR_NONE), MP_ROM_PTR(&watchdog_watchdogmode_none_obj)},
{MP_ROM_QSTR(MP_QSTR_RAISE), MP_ROM_PTR(&watchdog_watchdogmode_raise_obj)},
{MP_ROM_QSTR(MP_QSTR_RESET), MP_ROM_PTR(&watchdog_watchdogmode_reset_obj)},
};
STATIC MP_DEFINE_CONST_DICT(watchdog_watchdogmode_locals_dict, watchdog_watchdogmode_locals_dict_table);
STATIC void watchdog_watchdogmode_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
qstr runmode = MP_QSTR_NONE;
if (MP_OBJ_TO_PTR(self_in) == MP_ROM_PTR(&watchdog_watchdogmode_raise_obj)) {
runmode = MP_QSTR_RAISE;
}
else if (MP_OBJ_TO_PTR(self_in) == MP_ROM_PTR(&watchdog_watchdogmode_reset_obj)) {
runmode = MP_QSTR_RESET;
}
mp_printf(print, "%q.%q.%q", MP_QSTR_watchdog, MP_QSTR_WatchDogMode,
runmode);
}
const mp_obj_type_t watchdog_watchdogmode_type = {
{ &mp_type_type },
.name = MP_QSTR_WatchDogMode,
.print = watchdog_watchdogmode_print,
.locals_dict = (mp_obj_t)&watchdog_watchdogmode_locals_dict,
};

47
shared-bindings/watchdog/WatchDogMode.h Normal file
View File

@ -0,0 +1,47 @@
/*
* This file is part of the Micro Python project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2020 Sean Cross for Adafruit Industries
*
* 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.
*/
#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_WATCHDOG_WATCHDOGMODE_H
#define MICROPY_INCLUDED_SHARED_BINDINGS_WATCHDOG_WATCHDOGMODE_H
#include "py/obj.h"
typedef enum {
WATCHDOGMODE_NONE,
WATCHDOGMODE_RAISE,
WATCHDOGMODE_RESET,
} watchdog_watchdogmode_t;
const mp_obj_type_t watchdog_watchdogmode_type;
typedef struct {
mp_obj_base_t base;
} watchdog_watchdogmode_obj_t;
extern const watchdog_watchdogmode_obj_t watchdog_watchdogmode_none_obj;
extern const watchdog_watchdogmode_obj_t watchdog_watchdogmode_raise_obj;
extern const watchdog_watchdogmode_obj_t watchdog_watchdogmode_reset_obj;
#endif // MICROPY_INCLUDED_SHARED_BINDINGS_WATCHDOG_WATCHDOGMODE_H

21
shared-bindings/watchdog/__init__.c
View File

@ -28,6 +28,7 @@
#include "py/runtime.h"
#include "shared-bindings/watchdog/__init__.h"
#include "shared-bindings/watchdog/WatchDogMode.h"
//| """Watchdog Timer
//|
@ -47,7 +48,21 @@
//|
//| Example usage::
//|
//| from microcontroller.watchdog import WatchDogTimer
//| wdt = WatchDogTimer(timeout=2.5) # enable it with a timeout of 2.5 seconds
//| wdt.feed()"""
//| from microcontroller import watchdog as w
//| from watchdog import WatchDogMode
//| w.timeout=2.5 # Set a timeout of 2.5 seconds
//| w.mode = WatchDogMode.RAISE
//| w.feed()"""
//|
STATIC const mp_rom_map_elem_t watchdog_module_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_watchdog) },
{ MP_ROM_QSTR(MP_QSTR_WatchDogMode), MP_ROM_PTR(&watchdog_watchdogmode_type) },
};
STATIC MP_DEFINE_CONST_DICT(watchdog_module_globals, watchdog_module_globals_table);
const mp_obj_module_t watchdog_module = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t*)&watchdog_module_globals,
};

2
shared-bindings/watchdog/__init__.h
View File

@ -27,6 +27,6 @@
#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_WATCHDOG___INIT___H
#define MICROPY_INCLUDED_SHARED_BINDINGS_WATCHDOG___INIT___H
extern const mp_obj_type_t watchdog_type;
extern const mp_obj_module_t watchdog_module;
#endif // MICROPY_INCLUDED_SHARED_BINDINGS_WATCHDOG___INIT___H