DLPS

The example performs deep low-power state (DLPS) wake-up by using different peripherals.

The peripherals included in the example are ADC , GPIO, UART, LPC, RTC, and AON QDEC.

The ADC, GPIO and UART examples are PAD wake-ups, and the LPC, RTC, and AON QDEC are all wake-up sources for the peripherals themselves. For more information on low-power modes, refer to document Low Power Mode.

Requirements

The sample supports the following development kits:

Development Kits
Hardware Platforms	Board Name
RTL87x2G HDK	RTL87x2G EVB

For more requirements, please refer to Quick Start.

Configurations

The example can be configured with different DLPS examples using the following macros:

CONFIG_ADC_GPIO_DLPS_EN : PAD wake-up, ADC sampling within GPIO interrupt.
CONFIG_UART_DLPS_EN : PAD wake-up, UART receive data wake-up, continue UART data sending and receiving after wake-up.
CONFIG_RTC_DLPS_EN : RTC timing time to wake up the system.
CONFIG_AON_QDEC_DLPS_EN : Wake up the system by scrolling the mouse wheel.
CONFIG_LPC_DLPS_EN : Wake up when voltage comparison meets condition.

Wiring

If enable CONFIG_ADC_GPIO_DLPS_EN

Connect P4_0 to external input.
If enable CONFIG_UART_DLPS_EN

The EVB is externally connected to an FT232 module, with P3_0 connected to the RX pin of the FT232, and P3_1 connected to the TX pin of the FT232.
If enable CONFIG_AON_QDEC_DLPS_EN

The EVB is externally connected to a rotation sensor module, with P1_3 connected to Phase A and P1_4 connected to Phase B.
If enable CONFIG_LPC_DLPS_EN

Connect P2_4 to external input voltage.

Building and Downloading

This sample can be found in the SDK folder:

Keil

Project file: samples\lowpower\dlps\proj\rtl87x2g\mdk

GCC

Project file: samples\lowpower\dlps\proj\rtl87x2g\gcc

To build and run the sample, follow the steps listed below:

Open sample project file.
To build the target, follow the steps listed on the Generating App Image in Quick Start.
After a successful compilation, the app bin app_MP_xxx.bin will be generated in the directory mdk\bin or gcc\bin.
To download app bin into EVB board, follow the steps listed on the MP Tool Download in Quick Start.
Press reset button on EVB board and it will start running.

Experimental Verification

If enable CONFIG_ADC_GPIO_DLPS_EN

When pin P4_0 is input low, wake up the system and enter the GPIO interrupt.

Enable ADC sampling within the GPIO interrupt to print the VBAT voltage.
If enable CONFIG_UART_DLPS_EN

The serial assistant sends a message to the MCU to wake up the system.

Send the message again and the MCU replies with the same message to the serial assistant.
If enable CONFIG_RTC_DLPS_EN

RTC exits DLPS every 0.1s timing, enters RTC_INT_TICK interrupt, prints the interrupt message, and enters DLPS again. After 20 times, it no longer enters the DLPS state.
If enable CONFIG_AON_QDEC_DLPS_EN

Roll the mouse wheel, wake up the system, print the interrupt message, the direction and number of wheel rolls. After 20 times, no more DLPS state.
If enable CONFIG_LPC_DLPS_EN

Pin P2_4 input voltage meets the set threshold condition, it will wake up the system and trigger the LPC interrupt.

Code Overview

This chapter will be introduced according to the following several parts:

Source Code Directory.
Peripheral initialization will be introduced in chapter Initialization.
Functional implementation after initialization will be introduced in chapter Functional Implementation.

Source Code Directory

Project directory: sdk\samples\lowpower\dlps\proj
Source code directory: sdk\samples\lowpower\dlps\src

Source files are currently categorized into several groups as below.

└── Project: dlps
    └── secure_only_app
        └── Device                   includes startup code
            ├── startup_rtl.c
            └── system_rtl.c
        ├── CMSIS                    includes CMSIS header files
        ├── CMSE Library             Non-secure callable lib
        ├── lib                      includes all binary symbol files that user application is built on
            └── rtl87x2g_io.lib
        ├── peripheral               includes all peripheral drivers and module code used by the application
            ├── rtl_gpio.c
            ├── rtl_adc.c
            ├── rtl_rtc.c
            ├── rtl_lpc.c
            ├── rtl_uart.c
            ├── rtl_aon_qdec.c
            ├── rtl_pinmux.c
            ├── rtl_nvic.c
            └── rtl_rcc.c
        └── APP                      includes the ble_peripheral user application implementation
            ├── io_adc.c
            ├── io_dlps.c
            ├── io_uart.c
            ├── io_rtc.c
            ├── io_aon_qdec.c
            ├── io_lpc.c
            └── main_ns.c

Initialization

The initialization process includes global_data_init , board_init , driver_init and pwr_mgr_init .

global_data_init contains initialisation of global variables.

global_data_uart_init : Set PowerCheck flag bit to PASS to allow access to the DLPS; Reset the UART receive length and the receive array.

global_data_adc_gpio_init : Set PowerCheck flag bit to PASS to allow access to the DLPS.
void global_data_adc_gpio_init(void)
{
   IO_ADC_GPIO_DLPS_Enter_Allowed = POWER_CHECK_PASS;
}

void global_data_uart_init(void)
{
   IO_UART_DLPS_Enter_Allowed = POWER_CHECK_PASS;
   UART_RX_Count = 0;
   memset(UART_RX_Buffer, 0, sizeof(UART_RX_Buffer));
}

board_init contains the PAD and PINMUX settings.

driver_init contains the initialization of each peripheral, including ADC, GPIO, UART, RTC, QDEC, LPC. Initialize the corresponding driver according to the macro configuration.

ADC Initialization

Channel 0 is configured for VBAT sampling with a corresponding Bitmap of 0x01.

Configure the ADC single sample completion interrupt ADC_INT_ONE_SHOT_DONE.

ADC_InitStruct.ADC_SchIndex[0]      = INTERNAL_VBAT_MODE;
ADC_InitStruct.ADC_Bitmap           = 0x01;
...
ADC_INTConfig(ADC, ADC_INT_ONE_SHOT_DONE, ENABLE);

GPIO Initialization

Configure the GPIO for input mode.
Enable GPIO interrupt and configure falling edge trigger.

Configure the GPIO Debounce function.

GPIO_InitStruct.GPIO_Pin        = GPIO_PIN_INPUT;
GPIO_InitStruct.GPIO_Mode       = GPIO_Mode_IN;
GPIO_InitStruct.GPIO_ITCmd      = ENABLE;
GPIO_InitStruct.GPIO_ITTrigger  = GPIO_INT_Trigger_EDGE;
GPIO_InitStruct.GPIO_ITPolarity = GPIO_INT_POLARITY_ACTIVE_LOW;
GPIO_InitStruct.GPIO_ITDebounce = GPIO_INT_DEBOUNCE_ENABLE;
...

UART Initialization

Use the default settings.

Configure the receive idle interrupt UART_INT_RX_IDLE and the line status interrupt UART_INT_RD_AVA.

UART_INTConfig(UART0, UART_INT_RD_AVA, ENABLE);
UART_INTConfig(UART0, UART_INT_RX_IDLE, ENABLE);

RTC Initialization

Set the RTC division factor to a clock frequency of 10Hz.
Enable RTC tick interrupt.
Enable RTC wake-up system function.

Reset the RTC count value and start the RTC peripheral.

RTC_SetPrescaler(RTC_PRESCALER_VALUE);
RTC_INTConfig(RTC_INT_TICK, ENABLE);
...
RTC_SystemWakeupConfig(ENABLE);
RTC_ResetCounter();
RTC_Cmd(ENABLE);

LPC Initialization

Set the LPC comparator output polarity.
Set the voltage threshold.
Enable the LPC function.
Enable LPC voltage compare polarity interrupt.

Enable LPC wake-up.

LPC_InitStruct.LPC_Channel    = LPC_CAPTURE_CHANNEL;
LPC_InitStruct.LPC_Edge       = LPC_VOLTAGE_DETECT_EDGE;
LPC_InitStruct.LPC_Threshold  = LPC_1000_mV;
LPC_Init(LPC0, &LPC_InitStruct);
LPC_INTConfig(LPC0, LPC_INT_LPCOMP, ENABLE);
LPC_Cmd(LPC0, ENABLE);
LPC_WKCmd(LPC0, ENABLE);

AON QDEC Initialization

Enable the X-axis function and enable the de-jitter function.
Enable AON QDEC X-axis new data generation interrupt AON_QDEC_X_INT_NEW_DATA and X-axis data exception interrupt AON_QDEC_X_INT_ILLEAGE .

Enable the QDEC X-axis channel.

QDEC_InitStruct.axisConfigX       = ENABLE;
QDEC_InitStruct.debounceEnableX   = ENABLE;
QDEC_InitStruct.manualLoadInitPhase = DISABLE;
...
AON_QDEC_INTConfig(AON_QDEC, AON_QDEC_X_INT_NEW_DATA, ENABLE);
AON_QDEC_INTConfig(AON_QDEC, AON_QDEC_X_INT_ILLEAGE, ENABLE);
AON_QDEC_Cmd(AON_QDEC, AON_QDEC_AXIS_X, ENABLE);
...

pwr_mgr_init contains power management initialization

Registers the user into the DLPS callback function app_enter_dlps_config and registers the user out of the DLPS callback function app_exit_dlps_config .
Registers hardware control callback functions DLPS_IO_EnterDlpsCb and DLPS_IO_ExitDlpsCb . Entering DLPS will save CPU, PINMUX, Peripheral, etc., and exiting DLPS will restore CPU, PINMUX, Peripheral, etc..

Sets the power mode to DLPS mode.

power_check_cb_register(app_dlps_check_cb);
DLPS_IORegUserDlpsEnterCb(app_enter_dlps_config);
DLPS_IORegUserDlpsExitCb(app_exit_dlps_config);
DLPS_IORegister();
bt_power_mode_set(BTPOWER_DEEP_SLEEP);
power_mode_set(POWER_DLPS_MODE);

In app_enter_dlps_config, execute the enter DLPS callback function for different peripherals.

When configuring DLPS wake-up as PAD wake-up (ADC/GPIO, UART): set the pin to SW Mode and set the DLPS wake-up mode.

Pad_ControlSelectValue(ADC_GPIO_DLPS_WAKEUP_PIN, PAD_SW_MODE);
System_WakeUpPinEnable(ADC_GPIO_DLPS_WAKEUP_PIN, PAD_WAKEUP_POL_LOW, 0);

In app_exit_dlps_config, execute the exit DLPS callback functions for different peripherals.

When configuring DLPS wakeup as PAD wakeup (ADC/GPIO, UART): set the pin to PINMUX Mode.

When configuring DLPS wake-up as peripheral wake-up (AON QDEC, LPC, RTC): execute each peripheral application logic.

void io_adc_gpio_dlps_exit(void)
{
   /* Switch pad to Pinmux mode */
   Pad_ControlSelectValue(ADC_GPIO_DLPS_WAKEUP_PIN, PAD_PINMUX_MODE);
   ...
}

void io_rtc_dlps_exit(void)
{
   allow_count ++;
   DBG_DIRECT("DLPS EXIT, wake up reason 0x%x", power_get_wakeup_reason());
}

Functional Implementation

If enable CONFIG_ADC_GPIO_DLPS_EN:

When pin P4_0 is input low, the system exits the DLPS state and enters System_Handler when the system is woken up.

Clear the wake-up interrupt pending bit of P4_0.
Disable the wake-up function of P4_0.
IO_ADC_DLPS_Enter_Allowed is set to PM_CHECK_FAIL.

if (System_WakeUpInterruptValue(ADC_GPIO_DLPS_WAKEUP_PIN) == SET)
{
   Pad_ClearWakeupINTPendingBit(ADC_GPIO_DLPS_WAKEUP_PIN);
   System_WakeUpPinDisable(ADC_GPIO_DLPS_WAKEUP_PIN);
   IO_ADC_GPIO_DLPS_Enter_Allowed = POWER_CHECK_FAIL;
}

When pin P4_0 input is low, trigger GPIO_PIN_INPUT interrupt, enter interrupt handler function GPIO_Input_Handler.

Disable the GPIO interrupt and mask the GPIO interrupt.
Enable ADC one shot mode.
Clear the GPIO interrupt pending bit, unmask the GPIO interrupt, and enable the GPIO interrupt.

GPIO_INTConfig(GPIO_PORT, GPIO_PIN_INPUT, DISABLE);
GPIO_MaskINTConfig(GPIO_PORT, GPIO_PIN_INPUT, ENABLE);

ADC_Cmd(ADC, ADC_ONE_SHOT_MODE, ENABLE);

GPIO_ClearINTPendingBit(GPIO_PORT, GPIO_PIN_INPUT);
GPIO_MaskINTConfig(GPIO_PORT, GPIO_PIN_INPUT, DISABLE);
GPIO_INTConfig(GPIO_PORT, GPIO_PIN_INPUT, ENABLE);

When the ADC single conversion is completed, trigger the ADC_INT_ONE_SHOT_DONE interrupt and enter the interrupt handler function SAR_ADC_Handler.
1. Clear the ADC_INT_ONE_SHOT_DONE interrupt pending bit.
2. Read the sampled data and calculate the voltage value.
```
ADC_ClearINTPendingBit(ADC, ADC_INT_ONE_SHOT_DONE);
sample_data = ADC_ReadRawData(ADC, ADC_Schedule_Index_0);
sample_voltage = ADC_GetVoltage(DIVIDE_SINGLE_MODE, (int32_t)sample_data, &error_status);
```

If enable CONFIG_UART_DLPS_EN:

When sending data to IC via serial debugging assistant, UART_RX_PIN goes low, waking up DLPS and entering System_Handler.
1. Clear the wake-up interrupt pending bit of UART_RX_PIN.
2. Disable the wake-up function of UART_RX_PIN.
3. IO_UART_DLPS_Enter_Allowed value is set to PM_CHECK_FAIL.
```
if (System_WakeUpInterruptValue(UART_RX_PIN) == SET)
{
   System_WakeUpPinDisable(UART_RX_PIN);
   Pad_ClearWakeupINTPendingBit(UART_RX_PIN);
   IO_UART_DLPS_Enter_Allowed = POWER_CHECK_FAIL;
}
```
When UART receives data triggering UART_INT_RD_AVA interrupt, or when UART is idle triggering UART_INT_RX_IDLE interrupt, entering interrupt handler UART0_Handler.

Disable the UART_INT_RX_IDLE interrupt.

Send the data in UART_RX_Buffer to the PC via UART.

Initialise UART global data.

When the state of determining that the UART transmit buffer is empty is 0, the transmission is complete and IO_UART_DLPS_Enter_Allowed is set.
UART_INTConfig(UART0, UART_INT_RX_IDLE, DISABLE);
DBG_DIRECT("UART IDLE");

/* Send msg to app task */
uart_senddata_continuous(UART0, UART_RX_Buffer, UART_RX_Count);
global_data_uart_init();
while (UART_GetFlagStatus(UART0, UART_FLAG_TX_FIFO_EMPTY) == 0)
{
   IO_UART_DLPS_Enter_Allowed = POWER_CHECK_PASS;
}

UART_ClearRxFIFO(UART0);
UART_INTConfig(UART0, UART_INT_RX_IDLE, ENABLE);

If enable CONFIG_RTC_DLPS_EN:

RTC set time is up, wake up DLPS. At the same time, trigger interrupt, enter interrupt handler function RTC_Handler, print message, clear ticking interrupt.
```
if (RTC_GetINTStatus(RTC_INT_TICK) == SET)
{
   DBG_DIRECT("RTC_INT_TICK");
   RTC_ClearINTPendingBit(RTC_INT_TICK);
}
```

Every time exit DLPS, allow_count will increment by 1. When allow_count increments to 20, it will not enter DLPS state again.

POWER_CheckResult io_rtc_dlps_check(void)
{
   if (allow_count >= 20)
   {
      IO_RTC_DLPS_Enter_Allowed = POWER_CHECK_FAIL;
   }
   return IO_RTC_DLPS_Enter_Allowed;
}

If enable CONFIG_AON_QDEC_DLPS_EN:

When AON QDEC X-axis detects new data, it wakes up the system and triggers the AON_QDEC_X_INT_NEW_DATA interrupt, and enters the interrupt handler AON_QDEC_Handler.
1. Read X-axis motion direction, count value.
2. Print the interrupt information, wheel scrolling direction and counts.
3. Clear the AON_QDEC_CLR_NEW_CT_X interrupt hang bit.
```
X_Axis_Data.AxisDirection = AON_QDEC_GetAxisDirection(AON_QDEC, AON_QDEC_AXIS_X);
X_Axis_Data.AxisCount = AON_QDEC_GetAxisCount(AON_QDEC, AON_QDEC_AXIS_X);
DBG_DIRECT(...);
AON_QDEC_ClearINTPendingBit(AON_QDEC, AON_QDEC_CLR_NEW_CT_X);
```

Every time exit DLPS, allow_count will increment by 1. When allow_count increments to 20, it will not enter DLPS state again.

POWER_CheckResult io_aon_qdec_dlps_check(void)
{
   if (allow_count >= 20)
   {
      IO_AON_QDEC_DLPS_Enter_Allowed = POWER_CHECK_FAIL;
   }
   return IO_AON_QDEC_DLPS_Enter_Allowed;
}

If enable CONFIG_LPC_DLPS_EN:

Adjust the voltage value of the DC voltage regulator, when the detected voltage of P2_4 is higher than 1000mV, trigger the :c:marco:`LPC_INT_LPCOMP` interrupt and enter the interrupt handler function LPCOMP_Handler.
1. Disable the :c:marco:`LPC_INT_LPCOMP` interrupt.
2. Clear the :c:marco:`LPC_FLAG_LPCOMP` flag.
3. Determine if the interrupt is :c:marco:`LPC_FLAG_LPCOMP_AON`.
```
if (LPC_GetFlagStatus(LPC0, LPC_FLAG_LPCOMP) == SET)
{
   DBG_DIRECT("LPC COMP");
   LPC_ClearFlag(LPC0, LPC_FLAG_LPCOMP);
}

if (LPC_GetFlagStatus(LPC0, LPC_FLAG_LPCOMP_AON) == SET)
{
   DBG_DIRECT("LPC AON");
}
```