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

watchdog: rename module from `wdt` and move to `microcontroller` 

This also places it under the `microcontroller` object.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-05-21 13:47:23 +08:00
parent c23f151b6b
commit 595f6387c2
18 changed files with 384 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ports/nrf/boards/simmel/mpconfigboard.mk
View File

@ -24,7 +24,7 @@ CIRCUITPY_ROTARYIO = 0
CIRCUITPY_RTC = 1
CIRCUITPY_TOUCHIO = 0
CIRCUITPY_ULAB = 0
CIRCUITPY_WDT = 1
CIRCUITPY_WATCHDOG = 1
# Enable micropython.native
#CIRCUITPY_ENABLE_MPY_NATIVE = 1

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

@ -106,7 +106,6 @@ const mcu_processor_obj_t common_hal_mcu_processor_obj = {
};
#if CIRCUITPY_INTERNAL_NVM_SIZE > 0
// The singleton nvm.ByteArray object.
const nvm_bytearray_obj_t common_hal_mcu_nvm_obj = {
.base = {
@ -117,6 +116,16 @@ 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 = {
.base = {
.type = &watchdog_type,
},
.watchdogtimer = (mp_obj_t)&mp_const_none_obj,
};
#endif
STATIC const mp_rom_map_elem_t mcu_pin_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR_P0_00), MP_ROM_PTR(&pin_P0_00) },
{ MP_ROM_QSTR(MP_QSTR_P0_01), MP_ROM_PTR(&pin_P0_01) },

197
ports/nrf/common-hal/watchdog/WatchDogTimer.c Normal file
View File

@ -0,0 +1,197 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2019 Nick Moore 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 "py/obj.h"
#include "py/runtime.h"
#include "common-hal/watchdog/WatchDogTimer.h"
#include "nrf_wdt.h"
#define WATCHDOG_RELOAD_COUNT 2
void common_hal_watchdog_init(uint32_t duration, bool pause_during_sleep) {
unsigned int channel;
nrf_wdt_behaviour_t behaviour = NRF_WDT_BEHAVIOUR_RUN_SLEEP_HALT;
if (pause_during_sleep) {
behaviour = NRF_WDT_BEHAVIOUR_PAUSE_SLEEP_HALT;
}
nrf_wdt_behaviour_set(NRF_WDT, behaviour);
uint64_t ticks = (duration * 32768ULL) / 1000;
if (ticks > UINT32_MAX) {
mp_raise_ValueError(translate("timeout duration exceeded the maximum supported value"));
}
nrf_wdt_reload_value_set(NRF_WDT, (uint32_t) ticks);
for (channel = 0; channel < WATCHDOG_RELOAD_COUNT; channel++) {
nrf_wdt_reload_request_enable(NRF_WDT, channel);
}
nrf_wdt_task_trigger(NRF_WDT, NRF_WDT_TASK_START);
}
void common_hal_watchdog_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>
#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;
//| 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.
//|
//| """
//| ...
//|
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 };
static const mp_arg_t allowed_args[] = {
{MP_QSTR_timeout_ms, MP_ARG_INT | MP_ARG_REQUIRED},
{MP_QSTR_sleep, 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);
if (args[ARG_timeout_ms].u_int <= 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;
common_hal_watchdog_init(self->timeout, self->sleep);
wdt_singleton = self;
return MP_OBJ_FROM_PTR(self);
}
//| 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) {
(void)self_in;
common_hal_watchdog_feed();
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) {
(void)self_in;
common_hal_watchdog_disable();
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(watchdog_watchdogtimer_deinit_obj, watchdog_watchdogtimer_deinit);
//| timeout: int = ...
//| """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) {
watchdog_watchdogtimer_obj_t *self = MP_OBJ_TO_PTR(self_in);
return mp_obj_new_int(self->timeout);
}
MP_DEFINE_CONST_FUN_OBJ_1(watchdog_watchdogtimer_obj_get_timeout_obj, watchdog_watchdogtimer_obj_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,
(mp_obj_t)&mp_const_none_obj,
(mp_obj_t)&mp_const_none_obj},
};
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) },
};
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,
.locals_dict = (mp_obj_dict_t*)&watchdog_watchdogtimer_locals_dict,
};

22
shared-bindings/wdt/WDT.h → ports/nrf/common-hal/watchdog/WatchDogTimer.h
View File

@ -24,24 +24,16 @@
* THE SOFTWARE.
*/
#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_WDT_WDT_H
#define MICROPY_INCLUDED_SHARED_BINDINGS_WDT_WDT_H
#ifndef MICROPY_INCLUDED_NRF_COMMON_HAL_WATCHDOG_WATCHDOGTIMER_H
#define MICROPY_INCLUDED_NRF_COMMON_HAL_WATCHDOG_WATCHDOGTIMER_H
#include <stdint.h>
#include <stdbool.h>
#include "py/obj.h"
#include "shared-bindings/watchdog/WatchDogTimer.h"
extern void common_hal_wdt_init(uint32_t duration, bool pause_during_sleep);
extern void common_hal_wdt_feed(void);
extern void common_hal_wdt_disable(void);
extern const mp_obj_type_t wdt_wdt_type;
typedef struct _wdt_wdt_obj_t {
typedef struct _watchdog_watchdogtimer_obj_t {
mp_obj_base_t base;
uint32_t timeout;
bool sleep;
} wdt_wdt_obj_t;
} watchdog_watchdogtimer_obj_t;
extern const wdt_wdt_obj_t wdt_wdt_obj;
#endif // MICROPY_INCLUDED_SHARED_BINDINGS_WDT_WDT_H
#endif // MICROPY_INCLUDED_NRF_COMMON_HAL_WATCHDOG_WATCHDOGTIMER_H

42
ports/nrf/common-hal/watchdog/__init__.c Normal file
View File

@ -0,0 +1,42 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2019 Nick Moore 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 "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,
};

38
ports/nrf/common-hal/watchdog/__init__.h Normal file
View File

@ -0,0 +1,38 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2018 Noralf Trønnes
*
* 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_NRF_COMMON_HAL_WATCHDOG___INIT___H
#define MICROPY_INCLUDED_NRF_COMMON_HAL_WATCHDOG___INIT___H
#include "py/obj.h"
#include "shared-bindings/watchdog/__init__.h"
typedef struct _watchdog_obj_t {
mp_obj_base_t base;
mp_rom_obj_t *watchdogtimer;
} watchdog_obj_t;
#endif // MICROPY_INCLUDED_NRF_COMMON_HAL_WATCHDOG___INIT___H

40
ports/nrf/common-hal/wdt/WDT.c
View File

@ -1,40 +0,0 @@
#include "py/obj.h"
#include "py/runtime.h"
#include "shared-bindings/rtc/__init__.h"
#include "nrf_wdt.h"
#define WDT_RELOAD_COUNT 2
void common_hal_wdt_init(uint32_t duration, bool pause_during_sleep) {
unsigned int channel;
nrf_wdt_behaviour_t behaviour = NRF_WDT_BEHAVIOUR_RUN_SLEEP_HALT;
if (pause_during_sleep) {
behaviour = NRF_WDT_BEHAVIOUR_PAUSE_SLEEP_HALT;
}
nrf_wdt_behaviour_set(NRF_WDT, behaviour);
uint64_t ticks = (duration * 32768ULL) / 1000;
if (ticks > UINT32_MAX) {
mp_raise_ValueError(translate("timeout duration exceeded the maximum supported value"));
}
nrf_wdt_reload_value_set(NRF_WDT, (uint32_t) ticks);
for (channel = 0; channel < WDT_RELOAD_COUNT; channel++) {
nrf_wdt_reload_request_enable(NRF_WDT, channel);
}
nrf_wdt_task_trigger(NRF_WDT, NRF_WDT_TASK_START);
}
void common_hal_wdt_feed(void) {
unsigned int channel;
for (channel = 0; channel < WDT_RELOAD_COUNT; channel++) {
nrf_wdt_reload_request_set(NRF_WDT, (nrf_wdt_rr_register_t)(NRF_WDT_RR0 + channel));
}
}
void common_hal_wdt_disable(void) {
// mp_raise_ValueError(translate("Watchdog timer cannot be disabled -- board will reset shortly"));
}

2
ports/nrf/mpconfigport.mk
View File

@ -37,7 +37,7 @@ CIRCUITPY_RGBMATRIX ?= 1
CIRCUITPY_FRAMEBUFFERIO ?= 1
CIRCUITPY_COUNTIO = 0
CIRCUITPY_WDT ?= 1
CIRCUITPY_WATCHDOG ?= 1
# nRF52840-specific

8
py/circuitpy_defns.mk
View File

@ -241,8 +241,8 @@ endif
ifeq ($(CIRCUITPY_USTACK),1)
SRC_PATTERNS += ustack/%
endif
ifeq ($(CIRCUITPY_WDT),1)
SRC_PATTERNS += wdt/%
ifeq ($(CIRCUITPY_WATCHDOG),1)
SRC_PATTERNS += watchdog/%
endif
ifeq ($(CIRCUITPY_PEW),1)
SRC_PATTERNS += _pew/%
@ -305,8 +305,8 @@ SRC_COMMON_HAL_ALL = \
rtc/__init__.c \
supervisor/Runtime.c \
supervisor/__init__.c \
wdt/__init__.c \
wdt/WDT.c \
watchdog/__init__.c \
watchdog/WatchDogTimer.c \
SRC_COMMON_HAL = $(filter $(SRC_PATTERNS), $(SRC_COMMON_HAL_ALL))

9
py/circuitpy_mpconfig.h
View File

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

4
py/circuitpy_mpconfig.mk
View File

@ -229,8 +229,8 @@ CIRCUITPY_ULAB ?= $(CIRCUITPY_FULL_BUILD)
CFLAGS += -DCIRCUITPY_ULAB=$(CIRCUITPY_ULAB)
# watchdog hardware support
CIRCUITPY_WDT ?= 0
CFLAGS += -DCIRCUITPY_WDT=$(CIRCUITPY_WDT)
CIRCUITPY_WATCHDOG ?= 0
CFLAGS += -DCIRCUITPY_WATCHDOG=$(CIRCUITPY_WATCHDOG)
# Enabled micropython.native decorator (experimental)
CIRCUITPY_ENABLE_MPY_NATIVE ?= 0

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

@ -167,6 +167,11 @@ STATIC const mp_rom_map_elem_t mcu_module_globals_table[] = {
#else
{ 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) },
#else
{ MP_ROM_QSTR(MP_QSTR_watchdog), MP_ROM_PTR(&mp_const_none_obj) },
#endif
{ MP_ROM_QSTR(MP_QSTR_RunMode), MP_ROM_PTR(&mcu_runmode_type) },
{ MP_ROM_QSTR(MP_QSTR_Pin), MP_ROM_PTR(&mcu_pin_type) },
{ MP_ROM_QSTR(MP_QSTR_pin), MP_ROM_PTR(&mcu_pin_module) },

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

@ -49,10 +49,13 @@ extern const mcu_processor_obj_t common_hal_mcu_processor_obj;
#if CIRCUITPY_INTERNAL_NVM_SIZE > 0
#include "common-hal/nvm/ByteArray.h"
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;
#endif
#endif // MICROPY_INCLUDED_SHARED_BINDINGS_MICROCONTROLLER___INIT___H

0
ports/nrf/common-hal/wdt/__init__.c → shared-bindings/watchdog/WatchDogTimer.c
View File

45
shared-bindings/watchdog/WatchDogTimer.h Normal file
View File

@ -0,0 +1,45 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2018 Noralf Trønnes
*
* 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_WATCHDOGTIMER_H
#define MICROPY_INCLUDED_SHARED_BINDINGS_WATCHDOG_WATCHDOGTIMER_H
#include <py/obj.h>
// extern void common_hal_wdt_init(uint32_t duration, bool pause_during_sleep);
// extern void common_hal_wdt_feed(void);
// extern void common_hal_wdt_disable(void);
// typedef struct _wdt_wdt_obj_t {
// mp_obj_base_t base;
// uint32_t timeout;
// bool sleep;
// } wdt_wdt_obj_t;
extern const mp_obj_type_t watchdog_watchdogtimer_type;
#endif // MICROPY_INCLUDED_SHARED_BINDINGS_WATCHDOG_WATCHDOGTIMER_H

38
shared-bindings/wdt/__init__.c → shared-bindings/watchdog/__init__.c
View File

@ -27,36 +27,40 @@
#include <string.h>
#include "py/runtime.h"
#include "shared-bindings/wdt/__init__.h"
#include "shared-bindings/wdt/WDT.h"
#include "shared-bindings/watchdog/__init__.h"
// #include "shared-bindings/wdt/WDT.h"
//| """Watchdog Timer
//|
//| The `wdt` module provides support for a Watchdog Timer. This timer will reset the device
//| The `watchdog` module provides support for a Watchdog Timer. This timer will reset the device
//| if it hasn't been fed after a specified amount of time. This is useful to ensure the board
//| has not crashed or locked up. You can enable thw watchdog timer using :class:`wdt.WDT`.
//| Note that the watchdog timer cannot be disabled once it has been enabled.
//| has not crashed or locked up. You can enable the watchdog timer using :class:`wdt.WDT`.
//| Note that on some platforms the watchdog timer cannot be disabled once it has been enabled.
//|
//| The WDT is used to restart the system when the application crashes and ends
//| The WatchDogTimer is used to restart the system when the application crashes and ends
//| up into a non recoverable state. Once started it cannot be stopped or
//| reconfigured in any way. After enabling, the application must "feed" the
//| watchdog periodically to prevent it from expiring and resetting the system.
//|
//| Note that this module can't be imported and used directly. The sole
//| instance of :class:`WatchDogTimer` is available at
//| :attr:`microcontroller.watchdog`."""
//|
//| Example usage::
//|
//| from machine import WDT
//| wdt = WDT(timeout=2000) # enable it with a timeout of 2s
//| from microcontroller.watchdog import WatchDogTimer
//| wdt = WatchDogTimer(timeout=2.5) # enable it with a timeout of 2.5 seconds
//| wdt.feed()"""
//|
STATIC const mp_rom_map_elem_t wdt_module_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_wdt) },
{ MP_ROM_QSTR(MP_QSTR_WDT), MP_ROM_PTR(&wdt_wdt_type) },
};
// STATIC const mp_rom_map_elem_t wdt_module_globals_table[] = {
// { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_wdt) },
// { MP_ROM_QSTR(MP_QSTR_WDT), MP_ROM_PTR(&wdt_wdt_type) },
// };
STATIC MP_DEFINE_CONST_DICT(wdt_module_globals, wdt_module_globals_table);
// STATIC MP_DEFINE_CONST_DICT(wdt_module_globals, wdt_module_globals_table);
const mp_obj_module_t wdt_module = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t*)&wdt_module_globals,
};
// const mp_obj_module_t wdt_module = {
// .base = { &mp_type_module },
// .globals = (mp_obj_dict_t*)&wdt_module_globals,
// };

10
shared-bindings/wdt/__init__.h → shared-bindings/watchdog/__init__.h
View File

@ -24,11 +24,9 @@
* THE SOFTWARE.
*/
#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_WDT___INIT___H
#define MICROPY_INCLUDED_SHARED_BINDINGS_WDT___INIT___H
#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_WATCHDOG___INIT___H
#define MICROPY_INCLUDED_SHARED_BINDINGS_WATCHDOG___INIT___H
#include <stdint.h>
#include <stdbool.h>
extern const mp_obj_type_t watchdog_type;
#endif // MICROPY_INCLUDED_SHARED_BINDINGS_WDT___INIT___H
#endif // MICROPY_INCLUDED_SHARED_BINDINGS_WATCHDOG___INIT___H

128
shared-bindings/wdt/WDT.c
View File

@ -1,128 +0,0 @@
/*
* 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/wdt/__init__.h"
#include "shared-bindings/wdt/WDT.h"
static wdt_wdt_obj_t *wdt_singleton;
//| 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."""
//| ...
//|
STATIC mp_obj_t wdt_wdt_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 };
static const mp_arg_t allowed_args[] = {
{MP_QSTR_timeout_ms, MP_ARG_INT | MP_ARG_REQUIRED},
{MP_QSTR_sleep, 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);
if (args[ARG_timeout_ms].u_int <= 0) {
mp_raise_ValueError(translate("watchdog timeout must be greater than 0"));
}
wdt_wdt_obj_t *self = m_new_obj(wdt_wdt_obj_t);
self->base.type = &wdt_wdt_type;
self->timeout = args[ARG_timeout_ms].u_int;
self->sleep = args[ARG_sleep].u_bool;
common_hal_wdt_init(self->timeout, self->sleep);
wdt_singleton = self;
return MP_OBJ_FROM_PTR(self);
}
//| def feed(self):
//| """Feed the watchdog timer. This must be called regularly, otherwise
//| the system will reset."""
//| ...
//|
STATIC mp_obj_t wdt_wdt_feed(mp_obj_t self_in) {
(void)self_in;
common_hal_wdt_feed();
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(wdt_wdt_feed_obj, wdt_wdt_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 wdt_wdt_deinit(mp_obj_t self_in) {
(void)self_in;
common_hal_wdt_disable();
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(wdt_wdt_deinit_obj, wdt_wdt_deinit);
//| timeout: int = ...
//| """The maximum number of milliseconds that can elapse between calls
//| to feed()"""
//|
STATIC mp_obj_t wdt_wdt_obj_get_timeout(mp_obj_t self_in) {
wdt_wdt_obj_t *self = MP_OBJ_TO_PTR(self_in);
return mp_obj_new_int(self->timeout);
}
MP_DEFINE_CONST_FUN_OBJ_1(wdt_wdt_obj_get_timeout_obj, wdt_wdt_obj_get_timeout);
const mp_obj_property_t wdt_wdt_timeout_obj = {
.base.type = &mp_type_property,
.proxy = {(mp_obj_t)&wdt_wdt_obj_get_timeout_obj,
(mp_obj_t)&mp_const_none_obj,
(mp_obj_t)&mp_const_none_obj},
};
STATIC const mp_rom_map_elem_t wdt_wdt_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_feed), MP_ROM_PTR(&wdt_wdt_feed_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&wdt_wdt_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_timeout), MP_ROM_PTR(&wdt_wdt_timeout_obj) },
};
STATIC MP_DEFINE_CONST_DICT(wdt_wdt_locals_dict, wdt_wdt_locals_dict_table);
const mp_obj_type_t wdt_wdt_type = {
{ &mp_type_type },
.name = MP_QSTR_WDT,
.make_new = wdt_wdt_make_new,
.locals_dict = (mp_obj_dict_t*)&wdt_wdt_locals_dict,
};