S32K118_PWR Mode_switch_VLPSA_Abort Issue

[Kurubara]

Hi Team, 

                   Im facing Issue Like When im Switching from the VLPR to VLPs Power Mode Im Not able to Switch the Sleep State to DeepSleep State Due to VLPSA Bit Was Set 1 As Information Mention In the S32K1XX Micro Reference Manual 

Very Low Power Stop Aborted
When set, this read-only status bit indicates an interrupt occurred during the previous stop mode entry
sequence, preventing the system from entering that mode. This field is cleared by reset or by hardware at
the beginning of any stop mode entry sequence and is set if the sequence was aborted.
NOTE: This bit will not get set if STOP1/STOP2 get aborted.
0 The previous stop mode entry was successful.
1 The previous stop mode entry was aborted 

As Mentioned Above State Was Setting How Could I Identify the Where Exactly The Status Read from the Interrupt.

Could Please the Below Attached Snippet

[danielmartynek]

Hi @Kurubara,

Please disable all peripherals that are not used in VLPS mode.
For example, set the FlexCAN module to Module Disable mode.
Next, turn off all source clocks except SIRC and LPO.
Only after completing these steps should the system enter VLPS.

BR, Daniel

[Kurubara]

Hi Whatever Mention Same Reference of Application Note i Implemented Can check this was My Implementation both Sleep and Wakeup Sequence

void Enter_VLPS_Mode (void)
{
status_t retValue;

Turn_OFF_MODULE_POWER_ENABLE();
Accelerometer_Set_Low_Power_Mode (&ACC_Info);
// Delay_mSec(20);

Turn_OFF_AUX_BAT_MON_EN();
Turn_OFF_MAIN_BAT_MON_EN();
Turn_ON_LEVEL_TRANS_OE ();
Turn_ON_USB_FORCE_BOOT ();

INT_SYS_DisableIRQ(ADC0_IRQn);
INT_SYS_DisableIRQ(CAN0_ORed_0_31_MB_IRQn);
INT_SYS_DisableIRQ(CAN0_ORed_Err_Wakeup_IRQn);
INT_SYS_DisableIRQ(LPIT0_IRQn);
INT_SYS_DisableIRQ(LPUART1_RxTx_IRQn);
INT_SYS_DisableIRQ(LPUART0_RxTx_IRQn);
// INT_SYS_DisableIRQ(LPI2C0_Master_Slave_IRQn);
INT_SYS_DisableIRQ(FTFC_IRQn);
// INT_SYS_DisableIRQ(PORT_IRQn);

CAN_DeInit();
Pit_DeInit();
// LPI2C_DeInit();
UART_DeInit();

Turn_ON_Green_LED_1();
Turn_ON_Green_LED_2();

INT_SYS_ClearPending(ADC0_IRQn);
INT_SYS_ClearPending(CAN0_ORed_0_31_MB_IRQn);
INT_SYS_ClearPending(CAN0_ORed_Err_Wakeup_IRQn);
INT_SYS_ClearPending(LPIT0_IRQn);
INT_SYS_ClearPending(LPUART1_RxTx_IRQn);
INT_SYS_ClearPending(LPUART0_RxTx_IRQn);
INT_SYS_ClearPending(FTFC_IRQn);

RTC_SetAlarmAfterPeriod (Configured_Heartbeat_Frequency,0,0);
//
// status_t Status;
//
// Status = RTC_DRV_GetNextAlarmTime(RTCTIMER1, &AlarmTime);

//Delay_mSec(5000);

Accelerometer_Read_Data(&ACC_Info);

PINS_DRV_ClearPortIntFlagCmd(PORTD);

INT_SYS_ClearPending(PORT_IRQn);

// WDOG->CNT = 0xD928C520; // Unlock
// //WDOG_CNT = 0xD928C520;
// //WDOG->CS = WDOG_CS_CMD32EN_MASK | WDOG_CS_CLK_LPO_MASK;
// WDOG->CS &= ~WDOG_CS_INT_MASK; // Disable WDOG interrupt
// INT_SYS_ClearPending(WDOG_IRQn);
// INT_SYS_DisableIRQ(WDOG_IRQn);
//
// //SMC->PMPROT = SMC_PMPROT_AVLP_MASK;
// disable_clock_monitors();
// scg_configure_freq_for_VLPR();

retValue = POWER_SYS_SetMode(VLPR, POWER_MANAGER_POLICY_AGREEMENT);
if (retValue == STATUS_SUCCESS)
{
while (SMC->PMSTAT != 0x04);
}

// Disable all GPIO interrupts
for (int i = 0; i < 32; i++)
{
PORTA->PCR[i] &= ~PORT_PCR_IRQC_MASK;
PORTB->PCR[i] &= ~PORT_PCR_IRQC_MASK;
PORTC->PCR[i] &= ~PORT_PCR_IRQC_MASK;
PORTD->PCR[i] &= ~PORT_PCR_IRQC_MASK;
PORTE->PCR[i] &= ~PORT_PCR_IRQC_MASK;
}

// Clear flags
PORTA->ISFR = 0xFFFFFFFF;
PORTB->ISFR = 0xFFFFFFFF;
PORTC->ISFR = 0xFFFFFFFF;
PORTD->ISFR = 0xFFFFFFFF;
PORTE->ISFR = 0xFFFFFFFF;

// Clear NVIC
INT_SYS_ClearPending(PORT_IRQn);
INT_SYS_DisableIRQ(PORT_IRQn);
// /* Prepare deep sleep */
// PMC->REGSC |= PMC_REGSC_BIASEN_MASK;
// S32_SCB->SCR |= S32_SCB_SCR_SLEEPDEEP_MASK;
//// SMC->PMCTRL = SMC_PMCTRL_STOPM(0b010);
// Clear_All_Wake_Sources();
//__disable_irq();
//POWER_SYS_SetMode(VLPS, POWER_MANAGER_POLICY_AGREEMENT);
retValue = POWER_SYS_SetMode(VLPS, POWER_MANAGER_POLICY_AGREEMENT);
if (retValue == STATUS_SUCCESS)
{
// if (!POWER_SYS_GetCurrentMode() == POWER_MANAGER_VLPS)
// {
//
// }
}


STANDBY();
// After Wakeup initialize all the disabled peripherals.

// Enter_VLPR_Mode ();
//
// CAN_Init();
// Pit_Init();
// LPI2C_INIT();
// LPUART_Initialization();
//
// INT_SYS_EnableIRQ(ADC0_IRQn);
//
// INT_SYS_EnableIRQ(CAN0_ORed_0_31_MB_IRQn);
//
// INT_SYS_EnableIRQ(CAN0_ORed_Err_Wakeup_IRQn);
//
// INT_SYS_EnableIRQ(LPIT0_IRQn);
//
// INT_SYS_EnableIRQ(LPUART1_RxTx_IRQn);
//
// INT_SYS_EnableIRQ(LPUART0_RxTx_IRQn);
//
// INT_SYS_EnableIRQ(LPI2C0_Master_Slave_IRQn);
//
// INT_SYS_EnableIRQ(FTFC_IRQn);
//
// Turn_ON_MODULE_POWER_ENABLE();
}

void Restore_From_VLPS_To_RUN(void)
{
// Go back to RUN Mode
POWER_SYS_SetMode(RUN, POWER_MANAGER_POLICY_AGREEMENT);
while (SMC->PMSTAT != 0x01); // Ensure we are in RUN

// Restore the RUN cocke.
CLOCK_SYS_UpdateConfiguration(0U, CLOCK_MANAGER_POLICY_AGREEMENT);

// Bring the disabled things back.

Turn_ON_MODULE_POWER_ENABLE();
Turn_ON_AUX_BAT_MON_EN();
Turn_ON_MAIN_BAT_MON_EN();
Turn_OFF_LEVEL_TRANS_OE();
Turn_OFF_USB_FORCE_BOOT ();


// Re initialize the modules we have de-inititalized.

CAN_Init();
Pit_Init(); /* or LPIT_Init, be consistent with what you use */
LPI2C_INIT();
LPUART_Initialization();
ADC_Initialization();
CSEC_Init();
RTC_Init(); /* if you need it active right after wake */
Accelerometer_Init(&ACC_Info);

// Re enable the IRQ's we disabled.


INT_SYS_EnableIRQ(ADC0_IRQn);
INT_SYS_EnableIRQ(CAN0_ORed_0_31_MB_IRQn);
INT_SYS_EnableIRQ(CAN0_ORed_Err_Wakeup_IRQn);
INT_SYS_EnableIRQ(LPIT0_IRQn);
INT_SYS_EnableIRQ(LPUART1_RxTx_IRQn);
INT_SYS_EnableIRQ(LPUART0_RxTx_IRQn);
INT_SYS_EnableIRQ(FTFC_IRQn);

INT_SYS_EnableIRQGlobal();

}

[danielmartynek]

The VLPSA flag can be triggered when one of the peripherals, such as FlexCAN, fails to acknowledge the transition to VLPS mode.

It also appears that you are using very old drivers, likely the legacy SDK drivers, which are no longer supported. I strongly recommend migrating to the latest RTD drivers.

To debug this issue, open POWER_SYS_SetMode() and locate the WFI instruction in the corresponding sub‑function. Set a breakpoint at that point. When the core halts on the WFI, inspect all relevant clock and peripheral registers.

Regards,

Daniel 

[Kurubara]

Hi danielmartynak,
thank u for Quick Response, For S32K118, RFM‑quality software support is provided by NXP Real‑Time Drivers (RTD) v3.0.0. This release includes full quality and safety packages and is the recommended and supported solution for production‑grade applications, including correct VLPS handling. Legacy S32SDK drivers are no longer supported for RFM use. which RTD Version I Need to Use For RFM Quality.

[danielmartynek]

Hi @Kurubara,

You can use the latest S32K1_S32M24X Real Time Drivers AUTOSAR R21-11 Version 3.0.0 QLP06.

 

[Kurubara]

Hi @Daniel,
currently I'm Using SDK2.2 Version for S32K118 RFM there is not Exact RTD version We are using, Its only Flex CAN or Any Other peripherals also. Can i know the List of peripherals

[danielmartynek · Accepted solution]

HI @Kurubara,

The SDK is a legacy SW that is no longer supported.

Please use RTD.

You need to have compatible S32DS IDE.

BR, Daniel