circuitpython/ports/atmel-samd/common-hal/alarm/__init__.c
Dan Halbert 9307b62ad5 wip
2022-10-27 22:42:04 -04:00

223 lines
8.5 KiB
C

/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2021 Lucian Copeland 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/gc.h"
#include "py/obj.h"
#include "py/objtuple.h"
#include "py/runtime.h"
#include "shared-bindings/alarm/__init__.h"
#include "shared-bindings/alarm/SleepMemory.h"
#include "shared-bindings/alarm/pin/PinAlarm.h"
#include "shared-bindings/alarm/time/TimeAlarm.h"
#include "shared-bindings/microcontroller/__init__.h"
#include "shared/runtime/interrupt_char.h"
#include "samd/external_interrupts.h"
#include "supervisor/port.h"
#include "supervisor/workflow.h"
STATIC uint32_t TAMPID = 0;
// Singleton instance of SleepMemory.
const alarm_sleep_memory_obj_t alarm_sleep_memory_obj = {
.base = {
.type = &alarm_sleep_memory_type,
},
};
// Static alarm object recording alarm (if any) that woke up CircuitPython after light or deep sleep.
// This object lives across VM instantiations, so none of these objects can contain references to the heap.
static union {
alarm_pin_pinalarm_obj_t pin_alarm;
alarm_time_timealarm_obj_t time_alarm;
} wake_alarm;
void alarm_reset(void) {
// Reset the alarm flag
alarm_pin_pinalarm_reset();
alarm_time_timealarm_reset();
}
void alarm_get_wakeup_cause(void) {
// Called from rtc_init, just before SWRST of RTC. It is called
// at an early stage of main(), to save TAMPID from SWRST. Later,
// common_hal_alarm_record_wake_alarm is called to make a wakeup
// alarm from the deep sleep.
TAMPID = RTC->MODE0.TAMPID.reg;
}
bool common_hal_alarm_woken_from_sleep(void) {
return alarm_pin_pinalarm_woke_this_cycle() || alarm_time_timealarm_woke_this_cycle();
}
mp_obj_t common_hal_alarm_record_wake_alarm(void) {
// Called from main.c on the first start up, just before alarm_reset.
// Return a copy of wakeup alarm from deep sleep / fake deep sleep.
// In case of fake sleep, status should be left in TimeAlarm/PinAlarm.
bool true_deep = RSTC->RCAUSE.bit.BACKUP;
if (alarm_pin_pinalarm_woke_this_cycle()) {
TAMPID = RTC->MODE0.TAMPID.reg;
RTC->MODE0.TAMPID.reg = TAMPID; // clear register
return alarm_pin_pinalarm_record_wakeup_alarm(&wake_alarm.pin_alarm, TAMPID);
}
if (alarm_time_timealarm_woke_this_cycle() || (true_deep && TAMPID == 0)) {
return alarm_time_timealarm_record_wakeup_alarm(&wake_alarm.time_alarm);
}
if (true_deep) {
return alarm_pin_pinalarm_record_wakeup_alarm(&wake_alarm.pin_alarm, TAMPID);
}
return mp_const_none;
}
// Set up light sleep or deep sleep alarms.
STATIC void _setup_sleep_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms) {
alarm_pin_pinalarm_set_alarms(deep_sleep, n_alarms, alarms);
alarm_time_timealarm_set_alarms(deep_sleep, n_alarms, alarms);
}
mp_obj_t common_hal_alarm_light_sleep_until_alarms(size_t n_alarms, const mp_obj_t *alarms) {
_setup_sleep_alarms(false, n_alarms, alarms);
mp_obj_t wake_alarm = mp_const_none;
// This works but achieves same power consumption as time.sleep()
PM->SLEEPCFG.reg = PM_SLEEPCFG_SLEEPMODE_STANDBY;
while (PM->SLEEPCFG.bit.SLEEPMODE != PM_SLEEPCFG_SLEEPMODE_STANDBY_Val) {
}
// STDBYCFG is left to be 0 to retain SYSRAM. Note that, even if
// RAMCFG_OFF is set here, SYSRAM seems to be retained, probably
// because RTC and/or USB keeps sleepwalking.
while (!mp_hal_is_interrupted()) {
RUN_BACKGROUND_TASKS;
// Detect if interrupt was alarm or ctrl-C interrupt.
if (alarm_time_timealarm_woke_this_cycle()) {
wake_alarm = alarm_time_timealarm_find_triggered_alarm(n_alarms,alarms);
break;
}
if (alarm_pin_pinalarm_woke_this_cycle()) {
wake_alarm = alarm_pin_pinalarm_find_triggered_alarm(n_alarms,alarms);
break;
}
// Clear the FPU interrupt because it can prevent us from sleeping.
if (__get_FPSCR() & ~(0x9f)) {
__set_FPSCR(__get_FPSCR() & ~(0x9f));
(void)__get_FPSCR();
}
common_hal_mcu_disable_interrupts();
__DSB(); // Data Synchronization Barrier
__WFI(); // Wait For Interrupt
common_hal_mcu_enable_interrupts();
}
// Restore SLEEPCFG or port_idle_until_interrupt sleeps in STANDBY mode.
PM->SLEEPCFG.reg = PM_SLEEPCFG_SLEEPMODE_IDLE2;
while (PM->SLEEPCFG.bit.SLEEPMODE != PM_SLEEPCFG_SLEEPMODE_IDLE2_Val) {
}
alarm_pin_pinalarm_deinit_alarms(n_alarms, alarms); // after care for alarm_pin_pinalarm_set_alarms
alarm_reset();
if (mp_hal_is_interrupted()) {
return mp_const_none; // Shouldn't be given to python code because exception handling should kick in.
}
return wake_alarm;
}
void common_hal_alarm_set_deep_sleep_alarms(size_t n_alarms, const mp_obj_t *alarms, size_t n_dios, digitalio_digitalinout_obj_t **preserve_dios) {
if (n_dios > 0) {
mp_raise_NotImplementedError_varg(translate("%q"), MP_QSTR_preserve_dios);
}
_setup_sleep_alarms(true, n_alarms, alarms);
}
void NORETURN common_hal_alarm_enter_deep_sleep(void) {
alarm_pin_pinalarm_prepare_for_deep_sleep();
alarm_time_timealarm_prepare_for_deep_sleep();
// port_disable_tick(); // TODO: Required for SAMD?
// cache alarm flag and etc since RTC about to be reset
uint32_t _flag = SAMD_ALARM_FLAG; // RTC->MODE0.BKUP[0].reg
uint32_t _target = RTC->MODE0.COMP[1].reg;
uint32_t _tampctrl = RTC->MODE0.TAMPCTRL.reg;
// Clear the FPU interrupt because it can prevent us from sleeping.
if (__get_FPSCR() & ~(0x9f)) {
__set_FPSCR(__get_FPSCR() & ~(0x9f));
(void)__get_FPSCR();
}
common_hal_mcu_disable_interrupts();
// Must disable the RTC before writing to EVCTRL and TMPCTRL
RTC->MODE0.CTRLA.bit.SWRST = 1; // Software reset the RTC
while (RTC->MODE0.SYNCBUSY.bit.SWRST) { // Wait for synchronization
}
RTC->MODE0.CTRLA.reg = RTC_MODE0_CTRLA_PRESCALER_DIV1024 | // Set prescaler to 1024
RTC_MODE0_CTRLA_MODE_COUNT32; // Set RTC to mode 0, 32-bit timer
SAMD_ALARM_FLAG = _flag;
// Check if we're setting TimeAlarm
if (SAMD_ALARM_FLAG_TIME_CHK) {
RTC->MODE0.COMP[1].reg = _target;
while (RTC->MODE0.SYNCBUSY.reg) {
}
RTC->MODE0.INTENSET.reg = RTC_MODE0_INTENSET_CMP1;
}
// Check if we're setting PinAlarm
if (SAMD_ALARM_FLAG_PIN_CHK) {
RTC->MODE0.TAMPCTRL.reg = _tampctrl;
RTC->MODE0.INTENSET.reg = RTC_MODE0_INTENSET_TAMPER;
}
// Enable interrupts
common_hal_mcu_enable_interrupts();
// Set-up Deep Sleep Mode with backup RAM retention
PM->SLEEPCFG.reg = PM_SLEEPCFG_SLEEPMODE_BACKUP;
while (PM->SLEEPCFG.bit.SLEEPMODE != PM_SLEEPCFG_SLEEPMODE_BACKUP_Val) {
}
RTC->MODE0.CTRLA.bit.ENABLE = 1; // Enable the RTC
while (RTC->MODE0.SYNCBUSY.bit.ENABLE) { // Wait for synchronization
}
__DSB(); // Data Synchronization Barrier
__WFI(); // Wait For Interrupt
// The above shuts down RAM and triggers a reset, so we should never hit this
while (1) {
;
}
}
// Default common_hal_alarm_pretending_deep_sleep is defined in
// shared-bindings, which is used here. Note that "pretending" does
// not work on REPL; it only works for main.py (or code.py, ...).
void common_hal_alarm_gc_collect(void) {
gc_collect_ptr(shared_alarm_get_wake_alarm());
}