Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Alarm pool sleep changes#16454

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to ourterms of service andprivacy statement. We’ll occasionally send you account related emails.

Already on GitHub?Sign in to your account

Merged
Merged
Show file tree
Hide file tree
Changes fromall commits
Commits
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
82 changes: 68 additions & 14 deletionsports/rp2/modmachine.c
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -137,6 +137,12 @@ static void mp_machine_idle(void) {
MICROPY_INTERNAL_WFE(1);
}

static void alarm_sleep_callback(uint alarm_id) {
}

// Set this to 1 to enable some debug of the interrupt that woke the device
#define DEBUG_LIGHTSLEEP 0

static void mp_machine_lightsleep(size_t n_args, const mp_obj_t *args) {
mp_int_t delay_ms = 0;
bool use_timer_alarm = false;
Expand DownExpand Up@@ -167,6 +173,16 @@ static void mp_machine_lightsleep(size_t n_args, const mp_obj_t *args) {
}
#endif

#if MICROPY_PY_THREAD
static bool in_lightsleep;
if (in_lightsleep) {
// The other CPU is also in machine.lightsleep()
MICROPY_END_ATOMIC_SECTION(my_interrupts);
return;
}
in_lightsleep = true;
#endif

#if MICROPY_HW_ENABLE_USBDEV
// Only disable the USB clock if a USB host has not configured the device
// or if going to DORMANT mode.
Expand DownExpand Up@@ -206,6 +222,15 @@ static void mp_machine_lightsleep(size_t n_args, const mp_obj_t *args) {
// Disable ROSC.
rosc_hw->ctrl = ROSC_CTRL_ENABLE_VALUE_DISABLE << ROSC_CTRL_ENABLE_LSB;

#if DEBUG_LIGHTSLEEP
#if PICO_RP2040
uint32_t pending_intr = 0;
#else
uint32_t pending_intr[2] = { 0 };
#endif
#endif

bool alarm_armed = false;
if (n_args == 0) {
#if MICROPY_PY_NETWORK_CYW43
gpio_set_dormant_irq_enabled(CYW43_PIN_WL_HOST_WAKE, GPIO_IRQ_LEVEL_HIGH, true);
Expand All@@ -214,16 +239,7 @@ static void mp_machine_lightsleep(size_t n_args, const mp_obj_t *args) {
} else {
uint32_t save_sleep_en0 = clocks_hw->sleep_en0;
uint32_t save_sleep_en1 = clocks_hw->sleep_en1;
bool timer3_enabled = irq_is_enabled(3);

const uint32_t alarm_num = 3;
const uint32_t irq_num = TIMER_ALARM_IRQ_NUM(timer_hw, alarm_num);
if (use_timer_alarm) {
// Make sure ALARM3/IRQ3 is enabled on _this_ core
if (!timer3_enabled) {
irq_set_enabled(irq_num, true);
}
hw_set_bits(&timer_hw->inte, 1u << alarm_num);
// Use timer alarm to wake.
clocks_hw->sleep_en0 = 0x0;
#if PICO_RP2040
Expand All@@ -233,8 +249,11 @@ static void mp_machine_lightsleep(size_t n_args, const mp_obj_t *args) {
#else
#error Unknown processor
#endif
timer_hw->intr = 1u << alarm_num; // clear any IRQ
timer_hw->alarm[alarm_num] = timer_hw->timerawl + delay_ms * 1000;
hardware_alarm_claim(MICROPY_HW_LIGHTSLEEP_ALARM_NUM);
hardware_alarm_set_callback(MICROPY_HW_LIGHTSLEEP_ALARM_NUM, alarm_sleep_callback);
if (hardware_alarm_set_target(MICROPY_HW_LIGHTSLEEP_ALARM_NUM, make_timeout_time_ms(delay_ms)) == PICO_OK) {
alarm_armed = true;
}
} else {
// TODO: Use RTC alarm to wake.
clocks_hw->sleep_en0 = 0x0;
Expand DownExpand Up@@ -264,10 +283,17 @@ static void mp_machine_lightsleep(size_t n_args, const mp_obj_t *args) {
#endif

// Go into low-power mode.
__wfi();
if (alarm_armed) {
__wfi();

if (!timer3_enabled) {
irq_set_enabled(irq_num, false);
#if DEBUG_LIGHTSLEEP
#if PICO_RP2040
pending_intr = nvic_hw->ispr;
#else
pending_intr[0] = nvic_hw->ispr[0];
pending_intr[1] = nvic_hw->ispr[1];
#endif
#endif
}
clocks_hw->sleep_en0 = save_sleep_en0;
clocks_hw->sleep_en1 = save_sleep_en1;
Expand All@@ -282,6 +308,34 @@ static void mp_machine_lightsleep(size_t n_args, const mp_obj_t *args) {

// Re-sync mp_hal_time_ns() counter with aon timer.
mp_hal_time_ns_set_from_rtc();

// Note: This must be done after MICROPY_END_ATOMIC_SECTION
if (use_timer_alarm) {
if (alarm_armed) {
hardware_alarm_cancel(MICROPY_HW_LIGHTSLEEP_ALARM_NUM);
}
hardware_alarm_set_callback(MICROPY_HW_LIGHTSLEEP_ALARM_NUM, NULL);
hardware_alarm_unclaim(MICROPY_HW_LIGHTSLEEP_ALARM_NUM);

#if DEBUG_LIGHTSLEEP
// Check irq.h for the list of IRQ's
// for rp2040 00000042: TIMER_IRQ_1 woke the device as expected
// 00000020: USBCTRL_IRQ woke the device (probably early)
// For rp2350 00000000:00000002: TIMER0_IRQ_1 woke the device as expected
// 00000000:00004000: USBCTRL_IRQ woke the device (probably early)
#if PICO_RP2040
mp_printf(MP_PYTHON_PRINTER, "lightsleep: pending_intr=%08lx\n", pending_intr);
#else
mp_printf(MP_PYTHON_PRINTER, "lightsleep: pending_intr=%08lx:%08lx\n", pending_intr[1], pending_intr[0]);
#endif
#endif
}

#if MICROPY_PY_THREAD
// Clearing the flag here is atomic, and we know we're the ones who set it
// (higher up, inside the critical section)
in_lightsleep = false;
#endif
}

NORETURN static void mp_machine_deepsleep(size_t n_args, const mp_obj_t *args) {
Expand Down
3 changes: 2 additions & 1 deletionports/rp2/mpconfigport.h
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -198,8 +198,9 @@
#define MICROPY_PY_LWIP_SOCK_RAW (MICROPY_PY_LWIP)

// Hardware timer alarm index. Available range 0-3.
// Number 3 is currently used by pico-sdk (PICO_TIME_DEFAULT_ALARM_POOL_HARDWARE_ALARM_NUM)
// Number 3 is currently used by pico-sdkalarm pool(PICO_TIME_DEFAULT_ALARM_POOL_HARDWARE_ALARM_NUM)
#define MICROPY_HW_SOFT_TIMER_ALARM_NUM (2)
#define MICROPY_HW_LIGHTSLEEP_ALARM_NUM (1)

// fatfs configuration
#define MICROPY_FATFS_ENABLE_LFN (2)
Expand Down
12 changes: 1 addition & 11 deletionsports/rp2/mphalport.c
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -266,17 +266,7 @@ void soft_timer_init(void) {
}

void mp_wfe_or_timeout(uint32_t timeout_ms) {
soft_timer_entry_t timer;

// Note the timer doesn't have an associated callback, it just exists to create a
// hardware interrupt to wake the CPU
soft_timer_static_init(&timer, SOFT_TIMER_MODE_ONE_SHOT, 0, NULL);
soft_timer_insert(&timer, timeout_ms);

__wfe();

// Clean up the timer node if it's not already
soft_timer_remove(&timer);
best_effort_wfe_or_timeout(delayed_by_ms(get_absolute_time(), timeout_ms));
}

int mp_hal_is_pin_reserved(int n) {
Expand Down
67 changes: 67 additions & 0 deletionstests/ports/rp2/rp2_lightsleep_thread.py
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,67 @@
# Verify that a thread running on CPU1 can go to lightsleep
# and wake up in the expected timeframe
import _thread
import time
import unittest
from machine import lightsleep

N_SLEEPS = 5
SLEEP_MS = 250

IDEAL_RUNTIME = N_SLEEPS * SLEEP_MS
MAX_RUNTIME = (N_SLEEPS + 1) * SLEEP_MS
MAX_DELTA = 20


class LightSleepInThread(unittest.TestCase):
def thread_entry(self, is_thread=True):
for _ in range(N_SLEEPS):
lightsleep(SLEEP_MS)
if is_thread:
self.thread_done = True

def elapsed_ms(self):
return time.ticks_diff(time.ticks_ms(), self.t0)

def setUp(self):
self.thread_done = False
self.t0 = time.ticks_ms()

def test_cpu0_busy(self):
_thread.start_new_thread(self.thread_entry, ())
# CPU0 is busy-waiting not asleep itself
while not self.thread_done:
self.assertLessEqual(self.elapsed_ms(), MAX_RUNTIME)
self.assertAlmostEqual(self.elapsed_ms(), IDEAL_RUNTIME, delta=MAX_DELTA)

def test_cpu0_sleeping(self):
_thread.start_new_thread(self.thread_entry, ())
time.sleep_ms(MAX_RUNTIME)
self.assertTrue(self.thread_done)
self.assertAlmostEqual(self.elapsed_ms(), MAX_RUNTIME, delta=MAX_DELTA)

def test_cpu0_also_lightsleep(self):
_thread.start_new_thread(self.thread_entry, ())
time.sleep_ms(50) # account for any delay in starting the thread
self.thread_entry(False) # does the same lightsleep loop, doesn't set the done flag
while not self.thread_done:
time.sleep_ms(10)
#
# Only one thread can actually be in lightsleep at a time to avoid
# races, but otherwise the behaviour when both threads call lightsleep()
# is unspecified.
#
# Currently, the other thread will return immediately if one is already
# in lightsleep. Therefore, runtime can be between IDEAL_RUNTIME and
# IDEAL_RUNTIME * 2 depending on how many times the calls to lightsleep() race
# each other.
#
# Note this test case is really only here to ensure that the rp2 hasn't
# hung or failed to sleep at all - not to verify any correct behaviour
# when there's a race to call lightsleep().
self.assertGreaterEqual(self.elapsed_ms(), IDEAL_RUNTIME - MAX_DELTA)
self.assertLessEqual(self.elapsed_ms(), IDEAL_RUNTIME * 2 + MAX_DELTA)


if __name__ == "__main__":
unittest.main()
6 changes: 0 additions & 6 deletionstests/ports/rp2/rp2_machine_idle.py
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,3 @@
import sys
import machine
import time

Expand All@@ -18,11 +17,6 @@
# Verification uses the average idle time, as individual iterations will always
# have outliers due to interrupts, scheduler, etc.

# RP2350 currently fails this test because machine.idle() resumes immediately.
if "RP2350" in sys.implementation._machine:
print("SKIP")
raise SystemExit

ITERATIONS = 500
total = 0

Expand Down
Loading
[8]ページ先頭
©2009-2025 Movatter.jp