xiaozhengsheng/HL-PDJ-1
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初始版本

Browse Source
This commit is contained in:
xiaozhengsheng
2025-08-19 09:49:41 +08:00
parent 10f1ddf1c1
commit 6df0f7d96e
2974 changed files with 1712873 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

482
components/libraries/pwr_mgmt/nrf_pwr_mgmt.c Normal file
View File

@@ -0,0 +1,482 @@
/**
* Copyright (c) 2016 - 2020, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include "sdk_common.h"
#if NRF_MODULE_ENABLED(NRF_PWR_MGMT)
#include "nrf_pwr_mgmt.h"
#include "nrf.h"
#include "nrf_mtx.h"
#include "nrf_power.h"
#include "app_error.h"
#include "nrf_assert.h"
#include "nrf_log_ctrl.h"
#include "app_util_platform.h"
#define NRF_LOG_MODULE_NAME pwr_mgmt
#if NRF_PWR_MGMT_CONFIG_LOG_ENABLED
#define NRF_LOG_LEVEL NRF_PWR_MGMT_CONFIG_LOG_LEVEL
#define NRF_LOG_INFO_COLOR NRF_PWR_MGMT_CONFIG_INFO_COLOR
#define NRF_LOG_DEBUG_COLOR NRF_PWR_MGMT_CONFIG_DEBUG_COLOR
#else
#define NRF_LOG_LEVEL 0
#endif // NRF_PWR_MGMT_CONFIG_LOG_ENABLED
#include "nrf_log.h"
NRF_LOG_MODULE_REGISTER();
#ifdef SOFTDEVICE_PRESENT
#include "nrf_soc.h"
#include "nrf_sdh.h"
#endif // SOFTDEVICE_PRESENT
#if NRF_PWR_MGMT_CONFIG_USE_SCHEDULER
#if (APP_SCHEDULER_ENABLED != 1)
#error "APP_SCHEDULER is required."
#endif
#include "app_scheduler.h"
#endif // NRF_PWR_MGMT_CONFIG_USE_SCHEDULER
// Create section "pwr_mgmt_data".
NRF_SECTION_SET_DEF(pwr_mgmt_data,
nrf_pwr_mgmt_shutdown_handler_t,
NRF_PWR_MGMT_CONFIG_HANDLER_PRIORITY_COUNT);
static nrf_pwr_mgmt_evt_t m_pwr_mgmt_evt; /**< Event type which will be passed to the shutdown
handlers.*/
static nrf_mtx_t m_sysoff_mtx; /**< Module API lock.*/
static bool m_shutdown_started; /**< True if application started the shutdown preparation. */
static nrf_section_iter_t m_handlers_iter; /**< Shutdown handlers iterator. */
#if (NRF_PWR_MGMT_CONFIG_FPU_SUPPORT_ENABLED && __FPU_PRESENT)
#define PWR_MGMT_FPU_SLEEP_PREPARE() pwr_mgmt_fpu_sleep_prepare()
__STATIC_INLINE void pwr_mgmt_fpu_sleep_prepare(void)
{
uint32_t original_fpscr;
CRITICAL_REGION_ENTER();
original_fpscr = __get_FPSCR();
/*
* Clear FPU exceptions.
* Without this step, the FPU interrupt is marked as pending,
* preventing system from sleeping. Exceptions cleared:
* - IOC - Invalid Operation cumulative exception bit.
* - DZC - Division by Zero cumulative exception bit.
* - OFC - Overflow cumulative exception bit.
* - UFC - Underflow cumulative exception bit.
* - IXC - Inexact cumulative exception bit.
* - IDC - Input Denormal cumulative exception bit.
*/
__set_FPSCR(original_fpscr & ~0x9Fu);
__DMB();
NVIC_ClearPendingIRQ(FPU_IRQn);
CRITICAL_REGION_EXIT();
/*
* The last chance to indicate an error in FPU to the user
* as the FPSCR is now cleared
*
* This assert is related to previous FPU operations
* and not power management.
*
* Critical FPU exceptions signaled:
* - IOC - Invalid Operation cumulative exception bit.
* - DZC - Division by Zero cumulative exception bit.
* - OFC - Overflow cumulative exception bit.
*/
ASSERT((original_fpscr & 0x7) == 0);
}
#else
#define PWR_MGMT_FPU_SLEEP_PREPARE()
#endif // NRF_PWR_MGMT_CONFIG_FPU_SUPPORT_ENABLED
#if NRF_PWR_MGMT_CONFIG_DEBUG_PIN_ENABLED
#undef PWR_MGMT_SLEEP_IN_CRITICAL_SECTION_REQUIRED
#define PWR_MGMT_SLEEP_IN_CRITICAL_SECTION_REQUIRED
#include "nrf_gpio.h"
#define PWR_MGMT_DEBUG_PINS_INIT() pwr_mgmt_debug_pins_init()
#define PWR_MGMT_DEBUG_PIN_CLEAR() nrf_gpio_pin_clear(NRF_PWR_MGMT_SLEEP_DEBUG_PIN)
#define PWR_MGMT_DEBUG_PIN_SET() nrf_gpio_pin_set(NRF_PWR_MGMT_SLEEP_DEBUG_PIN)
__STATIC_INLINE void pwr_mgmt_debug_pins_init(void)
{
nrf_gpio_pin_clear(NRF_PWR_MGMT_SLEEP_DEBUG_PIN);
nrf_gpio_cfg_output(NRF_PWR_MGMT_SLEEP_DEBUG_PIN);
}
#else
#define PWR_MGMT_DEBUG_PIN_CLEAR()
#define PWR_MGMT_DEBUG_PIN_SET()
#define PWR_MGMT_DEBUG_PINS_INIT()
#endif
#if NRF_PWR_MGMT_CONFIG_CPU_USAGE_MONITOR_ENABLED
#undef PWR_MGMT_SLEEP_IN_CRITICAL_SECTION_REQUIRED
#define PWR_MGMT_SLEEP_IN_CRITICAL_SECTION_REQUIRED
#undef PWR_MGMT_TIMER_REQUIRED
#define PWR_MGMT_TIMER_REQUIRED
#include "app_timer.h"
#define PWR_MGMT_CPU_USAGE_MONITOR_INIT() pwr_mgmt_cpu_usage_monitor_init()
#define PWR_MGMT_CPU_USAGE_MONITOR_UPDATE() pwr_mgmt_cpu_usage_monitor_update()
#define PWR_MGMT_CPU_USAGE_MONITOR_SUMMARY() NRF_LOG_INFO("Maximum CPU usage: %u%%", \
m_max_cpu_usage)
#define PWR_MGMT_CPU_USAGE_MONITOR_SECTION_ENTER() \
{ \
uint32_t sleep_start = app_timer_cnt_get()
#define PWR_MGMT_CPU_USAGE_MONITOR_SECTION_EXIT() \
uint32_t sleep_end = app_timer_cnt_get(); \
uint32_t sleep_duration; \
sleep_duration = app_timer_cnt_diff_compute(sleep_end, \
sleep_start); \
m_ticks_sleeping += sleep_duration; \
}
static uint32_t m_ticks_sleeping; /**< Number of ticks spent in sleep mode (__WFE()). */
static uint32_t m_ticks_last; /**< Number of ticks from the last CPU usage computation. */
static uint8_t m_max_cpu_usage; /**< Maximum observed CPU usage (0 - 100%). */
__STATIC_INLINE void pwr_mgmt_cpu_usage_monitor_init(void)
{
m_ticks_sleeping = 0;
m_ticks_last = 0;
m_max_cpu_usage = 0;
}
__STATIC_INLINE void pwr_mgmt_cpu_usage_monitor_update(void)
{
uint32_t delta;
uint32_t ticks;
uint8_t cpu_usage;
ticks = app_timer_cnt_get();
delta = app_timer_cnt_diff_compute(ticks, m_ticks_last);
cpu_usage = 100 * (delta - m_ticks_sleeping) / delta;
NRF_LOG_INFO("CPU Usage: %u%%", cpu_usage);
if (m_max_cpu_usage < cpu_usage)
{
m_max_cpu_usage = cpu_usage;
}
m_ticks_last = ticks;
m_ticks_sleeping = 0;
}
#else
#define PWR_MGMT_CPU_USAGE_MONITOR_INIT()
#define PWR_MGMT_CPU_USAGE_MONITOR_UPDATE()
#define PWR_MGMT_CPU_USAGE_MONITOR_SUMMARY()
#define PWR_MGMT_CPU_USAGE_MONITOR_SECTION_ENTER()
#define PWR_MGMT_CPU_USAGE_MONITOR_SECTION_EXIT()
#endif // NRF_PWR_MGMT_CONFIG_CPU_USAGE_MONITOR_ENABLED
#if NRF_PWR_MGMT_CONFIG_STANDBY_TIMEOUT_ENABLED
#undef PWR_MGMT_TIMER_REQUIRED
#define PWR_MGMT_TIMER_REQUIRED
#define PWR_MGMT_STANDBY_TIMEOUT_INIT() pwr_mgmt_standby_timeout_clear()
#define PWR_MGMT_STANDBY_TIMEOUT_CLEAR() pwr_mgmt_standby_timeout_clear()
#define PWR_MGMT_STANDBY_TIMEOUT_CHECK() pwr_mgmt_standby_timeout_check()
static uint16_t m_standby_counter; /**< Number of seconds from the last activity
(@ref pwr_mgmt_feed). */
__STATIC_INLINE void pwr_mgmt_standby_timeout_clear(void)
{
m_standby_counter = 0;
}
__STATIC_INLINE void pwr_mgmt_standby_timeout_check(void)
{
if (m_standby_counter < NRF_PWR_MGMT_CONFIG_STANDBY_TIMEOUT_S)
{
m_standby_counter++;
}
else if (m_shutdown_started == false)
{
nrf_pwr_mgmt_shutdown(NRF_PWR_MGMT_SHUTDOWN_GOTO_SYSOFF);
}
}
#else
#define PWR_MGMT_STANDBY_TIMEOUT_INIT()
#define PWR_MGMT_STANDBY_TIMEOUT_CLEAR()
#define PWR_MGMT_STANDBY_TIMEOUT_CHECK()
#endif // NRF_PWR_MGMT_CONFIG_STANDBY_TIMEOUT_ENABLED
#if NRF_PWR_MGMT_CONFIG_AUTO_SHUTDOWN_RETRY
#undef PWR_MGMT_TIMER_REQUIRED
#define PWR_MGMT_TIMER_REQUIRED
#define PWR_MGMT_AUTO_SHUTDOWN_RETRY() pwr_mgmt_auto_shutdown_retry()
__STATIC_INLINE void pwr_mgmt_auto_shutdown_retry(void)
{
if (m_shutdown_started)
{
// Try to continue the shutdown procedure.
nrf_pwr_mgmt_shutdown(NRF_PWR_MGMT_SHUTDOWN_CONTINUE);
}
}
#else
#define PWR_MGMT_AUTO_SHUTDOWN_RETRY()
#endif // NRF_PWR_MGMT_CONFIG_AUTO_SHUTDOWN_RETRY
#ifdef PWR_MGMT_SLEEP_IN_CRITICAL_SECTION_REQUIRED
#define PWR_MGMT_SLEEP_INIT() pwr_mgmt_sleep_init()
#define PWR_MGMT_SLEEP_LOCK_ACQUIRE() CRITICAL_REGION_ENTER()
#define PWR_MGMT_SLEEP_LOCK_RELEASE() CRITICAL_REGION_EXIT()
__STATIC_INLINE void pwr_mgmt_sleep_init(void)
{
#ifdef SOFTDEVICE_PRESENT
ASSERT(current_int_priority_get() >= APP_IRQ_PRIORITY_LOW);
#endif
SCB->SCR |= SCB_SCR_SEVONPEND_Msk;
}
#else
#define PWR_MGMT_SLEEP_INIT()
#define PWR_MGMT_SLEEP_LOCK_ACQUIRE()
#define PWR_MGMT_SLEEP_LOCK_RELEASE()
#endif // PWR_MGMT_SLEEP_IN_CRITICAL_SECTION_REQUIRED
#ifdef PWR_MGMT_TIMER_REQUIRED
#include "app_timer.h"
#define PWR_MGMT_TIMER_CREATE() pwr_mgmt_timer_create()
APP_TIMER_DEF(m_pwr_mgmt_timer); /**< Timer used by this module. */
/**@brief Handle events from m_pwr_mgmt_timer.
*/
static void nrf_pwr_mgmt_timeout_handler(void * p_context)
{
PWR_MGMT_CPU_USAGE_MONITOR_UPDATE();
PWR_MGMT_AUTO_SHUTDOWN_RETRY();
PWR_MGMT_STANDBY_TIMEOUT_CHECK();
}
__STATIC_INLINE ret_code_t pwr_mgmt_timer_create(void)
{
ret_code_t ret_code = app_timer_create(&m_pwr_mgmt_timer,
APP_TIMER_MODE_REPEATED,
nrf_pwr_mgmt_timeout_handler);
if (ret_code != NRF_SUCCESS)
{
return ret_code;
}
return app_timer_start(m_pwr_mgmt_timer, APP_TIMER_TICKS(1000), NULL);
}
#else
#define PWR_MGMT_TIMER_CREATE() NRF_SUCCESS
#endif // PWR_MGMT_TIMER_REQUIRED
ret_code_t nrf_pwr_mgmt_init(void)
{
NRF_LOG_INFO("Init");
m_shutdown_started = false;
nrf_mtx_init(&m_sysoff_mtx);
nrf_section_iter_init(&m_handlers_iter, &pwr_mgmt_data);
PWR_MGMT_SLEEP_INIT();
PWR_MGMT_DEBUG_PINS_INIT();
PWR_MGMT_STANDBY_TIMEOUT_INIT();
PWR_MGMT_CPU_USAGE_MONITOR_INIT();
return PWR_MGMT_TIMER_CREATE();
}
void nrf_pwr_mgmt_run(void)
{
PWR_MGMT_FPU_SLEEP_PREPARE();
PWR_MGMT_SLEEP_LOCK_ACQUIRE();
PWR_MGMT_CPU_USAGE_MONITOR_SECTION_ENTER();
PWR_MGMT_DEBUG_PIN_SET();
// Wait for an event.
#ifdef SOFTDEVICE_PRESENT
if (nrf_sdh_is_enabled())
{
ret_code_t ret_code = sd_app_evt_wait();
ASSERT((ret_code == NRF_SUCCESS) || (ret_code == NRF_ERROR_SOFTDEVICE_NOT_ENABLED));
UNUSED_VARIABLE(ret_code);
}
else
#endif // SOFTDEVICE_PRESENT
{
// Wait for an event.
__WFE();
// Clear the internal event register.
__SEV();
__WFE();
}
PWR_MGMT_DEBUG_PIN_CLEAR();
PWR_MGMT_CPU_USAGE_MONITOR_SECTION_EXIT();
PWR_MGMT_SLEEP_LOCK_RELEASE();
}
void nrf_pwr_mgmt_feed(void)
{
NRF_LOG_DEBUG("Feed");
// It does not stop started shutdown process.
PWR_MGMT_STANDBY_TIMEOUT_CLEAR();
}
/**@brief Function runs the shutdown procedure.
*/
static void shutdown_process(void)
{
NRF_LOG_INFO("Shutdown started. Type %d", m_pwr_mgmt_evt);
// Executing all callbacks.
for (/* m_handlers_iter is initialized in nrf_pwr_mgmt_init(). Thanks to that each handler is
called only once.*/;
nrf_section_iter_get(&m_handlers_iter) != NULL;
nrf_section_iter_next(&m_handlers_iter))
{
nrf_pwr_mgmt_shutdown_handler_t * p_handler =
(nrf_pwr_mgmt_shutdown_handler_t *) nrf_section_iter_get(&m_handlers_iter);
if ((*p_handler)(m_pwr_mgmt_evt))
{
NRF_LOG_INFO("SysOff handler 0x%08X => ready", (unsigned int)*p_handler);
}
else
{
// One of the modules is not ready.
NRF_LOG_INFO("SysOff handler 0x%08X => blocking", (unsigned int)*p_handler);
return;
}
}
PWR_MGMT_CPU_USAGE_MONITOR_SUMMARY();
NRF_LOG_INFO("Shutdown complete.");
NRF_LOG_FINAL_FLUSH();
if ((m_pwr_mgmt_evt == NRF_PWR_MGMT_EVT_PREPARE_RESET)
|| (m_pwr_mgmt_evt == NRF_PWR_MGMT_EVT_PREPARE_DFU))
{
NVIC_SystemReset();
}
else
{
// Enter System OFF.
#ifdef SOFTDEVICE_PRESENT
if (nrf_sdh_is_enabled())
{
ret_code_t ret_code = sd_power_system_off();
ASSERT((ret_code == NRF_SUCCESS) || (ret_code == NRF_ERROR_SOFTDEVICE_NOT_ENABLED));
UNUSED_VARIABLE(ret_code);
#ifdef DEBUG
while (true)
{
/* Since the CPU is kept on in an emulated System OFF mode, it is recommended
* to add an infinite loop directly after entering System OFF, to prevent
* the CPU from executing code that normally should not be executed. */
__WFE();
}
#endif
}
#endif // SOFTDEVICE_PRESENT
nrf_power_system_off();
}
}
#if NRF_PWR_MGMT_CONFIG_USE_SCHEDULER
/**@brief Handle events from app_scheduler.
*/
static void scheduler_shutdown_handler(void * p_event_data, uint16_t event_size)
{
UNUSED_PARAMETER(p_event_data);
UNUSED_PARAMETER(event_size);
shutdown_process();
}
#endif // NRF_PWR_MGMT_CONFIG_USE_SCHEDULER
void nrf_pwr_mgmt_shutdown(nrf_pwr_mgmt_shutdown_t shutdown_type)
{
// Check if shutdown procedure is not started.
if (!nrf_mtx_trylock(&m_sysoff_mtx))
{
return;
}
if (shutdown_type != NRF_PWR_MGMT_SHUTDOWN_CONTINUE)
{
if (m_shutdown_started)
{
nrf_mtx_unlock(&m_sysoff_mtx);
return;
}
else
{
m_pwr_mgmt_evt = (nrf_pwr_mgmt_evt_t)shutdown_type;
m_shutdown_started = true;
}
}
ASSERT(m_shutdown_started);
NRF_LOG_INFO("Shutdown request %d", shutdown_type);
#if NRF_PWR_MGMT_CONFIG_USE_SCHEDULER
ret_code_t ret_code = app_sched_event_put(NULL, 0, scheduler_shutdown_handler);
APP_ERROR_CHECK(ret_code);
#else
shutdown_process();
#endif // NRF_PWR_MGMT_CONFIG_USE_SCHEDULER
nrf_mtx_unlock(&m_sysoff_mtx);
}
#endif // NRF_MODULE_ENABLED(NRF_PWR_MGMT)

158
components/libraries/pwr_mgmt/nrf_pwr_mgmt.h Normal file
View File

@@ -0,0 +1,158 @@
/**
* Copyright (c) 2016 - 2020, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/**
* @defgroup nrf_pwr_mgmt Power management
* @ingroup app_common
* @{
* @brief This module handles power management features.
*
*/
#ifndef NRF_PWR_MGMT_H__
#define NRF_PWR_MGMT_H__
#include <stdbool.h>
#include <stdint.h>
#include <sdk_errors.h>
#include "nrf_section_iter.h"
#ifdef __cplusplus
extern "C" {
#endif
/**@brief Power management shutdown types. */
typedef enum
{
NRF_PWR_MGMT_SHUTDOWN_GOTO_SYSOFF,
//!< Go to System OFF.
NRF_PWR_MGMT_SHUTDOWN_STAY_IN_SYSOFF,
//!< Go to System OFF and stay there.
/**<
* Useful when battery level is dangerously low, for example.
*/
NRF_PWR_MGMT_SHUTDOWN_GOTO_DFU,
//!< Go to DFU mode.
NRF_PWR_MGMT_SHUTDOWN_RESET,
//!< Reset chip.
NRF_PWR_MGMT_SHUTDOWN_CONTINUE
//!< Continue shutdown.
/**<
* This should be used by modules that block the shutdown process, when they become ready for
* shutdown.
*/
} nrf_pwr_mgmt_shutdown_t;
/**@brief Shutdown event types. */
typedef enum
{
NRF_PWR_MGMT_EVT_PREPARE_WAKEUP = NRF_PWR_MGMT_SHUTDOWN_GOTO_SYSOFF,
//!< Application will prepare the wakeup mechanism.
NRF_PWR_MGMT_EVT_PREPARE_SYSOFF = NRF_PWR_MGMT_SHUTDOWN_STAY_IN_SYSOFF,
//!< Application will prepare to stay in System OFF state.
NRF_PWR_MGMT_EVT_PREPARE_DFU = NRF_PWR_MGMT_SHUTDOWN_GOTO_DFU,
//!< Application will prepare to enter DFU mode.
NRF_PWR_MGMT_EVT_PREPARE_RESET = NRF_PWR_MGMT_SHUTDOWN_RESET,
//!< Application will prepare to chip reset.
} nrf_pwr_mgmt_evt_t;
/**@brief Shutdown callback.
* @param[in] event Type of shutdown process.
*
* @retval true System OFF / Enter DFU preparation successful. Process will be continued.
* @retval false System OFF / Enter DFU preparation failed. @ref NRF_PWR_MGMT_SHUTDOWN_CONTINUE
* should be used to continue the shutdown process.
*/
typedef bool (*nrf_pwr_mgmt_shutdown_handler_t)(nrf_pwr_mgmt_evt_t event);
/**@brief Macro for registering a shutdown handler. Modules that want to get events
* from this module must register the handler using this macro.
*
* @details This macro places the handler in a section named "pwr_mgmt_data".
*
* @param[in] _handler Event handler (@ref nrf_pwr_mgmt_shutdown_handler_t).
* @param[in] _priority Priority of the given handler.
*/
#define NRF_PWR_MGMT_HANDLER_REGISTER(_handler, _priority) \
STATIC_ASSERT(_priority < NRF_PWR_MGMT_CONFIG_HANDLER_PRIORITY_COUNT); \
/*lint -esym(528,*_handler_function) -esym(529,*_handler_function) : Symbol not referenced. */ \
NRF_SECTION_SET_ITEM_REGISTER(pwr_mgmt_data, _priority, \
static nrf_pwr_mgmt_shutdown_handler_t const CONCAT_2(_handler, _handler_function)) = (_handler)
/**@brief Function for initializing power management.
*
* @warning Depending on configuration, this function sets SEVONPEND in System Control Block (SCB).
* This operation is unsafe with the SoftDevice from interrupt priority higher than SVC.
*
* @retval NRF_SUCCESS
*/
ret_code_t nrf_pwr_mgmt_init(void);
/**@brief Function for running power management. Should run in the main loop.
*/
void nrf_pwr_mgmt_run(void);
/**@brief Function for indicating activity.
*
* @details Call this function whenever doing something that constitutes "activity".
* For example, whenever sending data, call this function to indicate that the application
* is active and should not disconnect any ongoing communication links.
*/
void nrf_pwr_mgmt_feed(void);
/**@brief Function for shutting down the system.
*
* @param[in] shutdown_type Type of operation.
*
* @details All callbacks will be executed prior to shutdown.
*/
void nrf_pwr_mgmt_shutdown(nrf_pwr_mgmt_shutdown_t shutdown_type);
#ifdef __cplusplus
}
#endif
#endif // NRF_PWR_MGMT_H__
/** @} */