/*
* ======== Power_sleep ========
*/
Power_Status Power_sleep(Power_SleepState sleepState, UArg arg0, UArg arg1)
{
Power_Status status = Power_SOK;
UInt xosc_hf_active = FALSE;
Power_Event postEventLate;
UInt32 poweredDomains = 0;
Bool exitNow = FALSE;
Power_Event preEvent;
Power_Event postEvent;
UInt32 constraints;
Bool retainCache = FALSE;
UInt32 modeVIMS;
UInt taskKey;
UInt swiKey;
UInt hwiKey;
/* first validate the sleep code */
if ( sleepState != Power_STANDBY) {
status = Power_EFAIL;
}
if (status == Power_SOK) {
/* make sure Power is not still busy with a previous transition */
hwiKey = Hwi_disable();
if (Power_module->state == Power_ACTIVE) {
/* set transition state to entering sleep */
Power_module->state = Power_ENTERING_SLEEP;
}
else {
exitNow = TRUE;
}
Hwi_restore(hwiKey);
if (exitNow == TRUE) {
status = Power_EBUSY;
}
else {
/* setup sleep vars */
if (sleepState == Power_STANDBY) {
preEvent = Power_ENTERING_STANDBY;
postEvent = Power_AWAKE_STANDBY;
postEventLate = Power_AWAKE_STANDBY_LATE;
}
/* disable Task scheduling; allow Swis and Hwis for notifications */
taskKey = Task_disable();
/* signal all clients registered for pre-sleep notification */
status = Power_notify(preEvent);
/* check for any error */
if (status != Power_SOK) {
Power_module->state = Power_ACTIVE;
Task_restore(taskKey); /* re-enable scheduler */
return (status);
}
/* now disable Swi scheduling */
swiKey = Swi_disable();
/* freeze the IOs on the boundary between MCU and AON */
AONIOCFreezeEnable();
/* if XOSC_HF is active, force it off */
if(OSCClockSourceGet(OSC_SRC_CLK_HF) == OSC_XOSC_HF) {
xosc_hf_active = TRUE;
ti_sysbios_family_arm_cc26xx_Power_XOSC_HF(DISABLE);
}
/* allow AUX to power down */
AONWUCAuxWakeupEvent(AONWUC_AUX_ALLOW_SLEEP);
/* make sure writes take effect */
SysCtrlAonSync();
/* invoke specific sequences to activate sleep states... */
if (sleepState == Power_STANDBY) {
/* query and save domain states before powering them off */
if (Power_getDependencyCount(DOMAIN_RFCORE)) {
poweredDomains |= PRCM_DOMAIN_RFCORE;
}
if (Power_getDependencyCount(DOMAIN_SERIAL)){
poweredDomains |= PRCM_DOMAIN_SERIAL;
}
if (Power_getDependencyCount(DOMAIN_PERIPH)) {
poweredDomains |= PRCM_DOMAIN_PERIPH;
}
/* gate running deep sleep clocks for Crypto and DMA */
if (Power_getDependencyCount(PERIPH_CRYPTO)) {
PRCMPeripheralDeepSleepDisable(
ti_sysbios_family_arm_cc26xx_Power_db[
PERIPH_CRYPTO].driverlibID);
}
if (Power_getDependencyCount(PERIPH_UDMA)) {
PRCMPeripheralDeepSleepDisable(
ti_sysbios_family_arm_cc26xx_Power_db[
PERIPH_UDMA].driverlibID);
}
/* make sure clock settings take effect */
PRCMLoadSet();
/* request power off of domains in the MCU voltage domain */
PRCMPowerDomainOff(poweredDomains | PRCM_DOMAIN_CPU);
/* request uLDO during standby */
PRCMMcuUldoConfigure(true);
/* query constraints to determine if cache should be retained */
constraints = Power_getConstraintInfo();
if ((constraints & Power_SB_VIMS_CACHE_RETAIN) != 0) {
retainCache = TRUE;
}
/* if don't want retention in standby, disable it now ... */
if (retainCache == FALSE) {
modeVIMS = VIMSModeGet(VIMS_BASE);
/* wait if invalidate in progress... */
while (modeVIMS == VIMS_MODE_CHANGING) {
modeVIMS = VIMSModeGet(VIMS_BASE);
}
PRCMCacheRetentionDisable();
VIMSModeSet(VIMS_BASE, VIMS_MODE_OFF);
}
/* setup recharge parameters */
SysCtrlSetRechargeBeforePowerDown(XoscInHighPowerMode);
/* make sure all writes have taken effect */
SysCtrlAonSync();
/* invoke deep sleep to go to STANDBY */
PRCMDeepSleep();
/* if didn't retain cache in standby, re-enable retention now */
if (retainCache == FALSE) {
VIMSModeSet(VIMS_BASE, modeVIMS);
PRCMCacheRetentionEnable();
}
/* force power on of AUX to keep it on when system is not
* sleeping; this also counts as a write to the AON interface
* ensuring that a following sync of the AON interface will
* force an update of all registers
*/
AONWUCAuxWakeupEvent(AONWUC_AUX_WAKEUP);
while(!(AONWUCPowerStatusGet() & AONWUC_AUX_POWER_ON)) {};
/* if XOSC_HF was forced off above, initiate switch back */
if (xosc_hf_active == TRUE) {
ti_sysbios_family_arm_cc26xx_Power_XOSC_HF(ENABLE);
}
/* restore power domain states in effect before standby */
PRCMPowerDomainOn(poweredDomains);
while (PRCMPowerDomainStatus(poweredDomains) !=
PRCM_DOMAIN_POWER_ON){};
/* restore deep sleep clocks of Crypto and DMA */
if (Power_getDependencyCount(PERIPH_CRYPTO)) {
PRCMPeripheralDeepSleepEnable(
ti_sysbios_family_arm_cc26xx_Power_db[
PERIPH_CRYPTO].driverlibID);
}
if (Power_getDependencyCount(PERIPH_UDMA)) {
PRCMPeripheralDeepSleepEnable(
ti_sysbios_family_arm_cc26xx_Power_db[
PERIPH_UDMA].driverlibID);
}
/* make sure clock settings take effect */
PRCMLoadSet();
}
/* release request for uLDO */
PRCMMcuUldoConfigure(false);
/* set transition state to EXITING_SLEEP */
Power_module->state = Power_EXITING_SLEEP;
/*
* signal clients registered for early post-sleep notification;
* this should be used to initialize any timing critical or IO
* dependent hardware
*/
status = Power_notify(postEvent);
/* disable IO freeze and ensure RTC shadow value is updated */
AONIOCFreezeDisable();
SysCtrlAonSync();
/* re-enable interrupts */
CPUcpsie();
/* signal all clients registered for late post-sleep notification */
status = Power_notify(postEventLate);
/* now clear the transition state before re-enabling scheduler */
Power_module->state = Power_ACTIVE;
/* re-enable Swi scheduling */
Swi_restore(swiKey);
/* adjust recharge parameters */
SysCtrlAdjustRechargeAfterPowerDown();
/* re-enable Task scheduling */
Task_restore(taskKey);
/* check for any notification error */
if (status != Power_SOK) {
return (status);
}
}
}
return (status);
}
//*****************************************************************************
//
// Force the system in to low power modes.
//
//*****************************************************************************
void
PowerCtrlStateSet(uint32_t ui32Powerstate)
{
//
// Check the arguments.
//
ASSERT((ui32Powerstate == PWRCTRL_STANDBY) ||
(ui32Powerstate == PWRCTRL_POWER_DOWN) ||
(ui32Powerstate == PWRCTRL_SHUTDOWN));
//
// Configure the desired power state.
//
if(ui32Powerstate == PWRCTRL_STANDBY)
{
//
//
// Turn of all power domains in the MCU voltage domain. This is
// necessary to conserve power before switching to the uLDO.
//
PRCMPowerDomainOff(PRCM_DOMAIN_RFCORE | PRCM_DOMAIN_SERIAL |
PRCM_DOMAIN_PERIPH | PRCM_DOMAIN_CPU |
PRCM_DOMAIN_VIMS);
//
// Make sure to request power off of the JTAG domain.
//
AONWUCJtagPowerOff();
//
// Configuration of clock source for MCU and AUX in standby mode.
//
AONWUCMcuPowerDownConfig(AONWUC_CLOCK_SRC_LF);
AONWUCAuxPowerDownConfig(AONWUC_CLOCK_SRC_LF);
//
// Configure the recharge controller and request the uLDO as power
// source.
//
AONWUCRechargeCtrlConfigSet(true, 34, 2500, 5000);
//
// Enable AUX power down
// This will tell the system that no HF source is needed and will
// allow the system to use the low-leakage/effect power supply.
// NB. This does not allow co-existence of an independent
// Sensor Controller.
//
AUXWUCPowerCtrl(AUX_WUC_POWER_DOWN);
while(AONWUCPowerStatusGet() & AONWUC_AUX_POWER_ON);
//
// Request the uLDO for standby power consumption.
//
PowerCtrlSourceSet(PWRCTRL_PWRSRC_ULDO);
//
// Sync the AON interface to ensure all writes have gone through
//
HWREG(AON_RTC_BASE + AON_RTC_O_SYNC);
//
// Enable transition to standby.
//
PRCMDeepSleep();
}
else if(ui32Powerstate == PWRCTRL_POWER_DOWN)
{
//
// Latch the current IO configuration before going to sleep to ensure
// the IOs retain their value even after boot and reset of the
// configuration.
//
AONIOCFreezeEnable();
//
// Make sure retention on MCU SRAM is on - on pr. default.
//
AONWUCMcuSRamConfig(MCU_RAM0_RETENTION | MCU_RAM1_RETENTION |
MCU_RAM2_RETENTION | MCU_RAM3_RETENTION);
//
// Allow power off on all domains in the MCU voltage domain.
// This is necessary to conserve power before switching to the uLDO.
//
PRCMPowerDomainOff(PRCM_DOMAIN_RFCORE | PRCM_DOMAIN_SERIAL |
PRCM_DOMAIN_PERIPH | PRCM_DOMAIN_CPU |
PRCM_DOMAIN_VIMS);
//
// Turn off the MCU voltage domain. This will not take effect until System CPU
// is in deep sleep.
//
PRCMMcuPowerOff();
//
// Set the wake up mode - default value coming out of reset
//
AONWUCMcuWakeUpConfig(MCU_IMM_WAKE_UP);
//
// VIRTUAL POWER OFF DISABLE is the default value coming out of reset
//
AONWUCMcuPowerOffConfig(MCU_VIRT_PWOFF_DISABLE);
//
// Configure the recharge controller and request the uLDO as power
// source.
// Recommended maximum numbers for lowest power consumption
// AdaptRate = 96
// MaxPeriod = 21440
// InitPeriod = 14816
//
AONWUCRechargeCtrlConfigSet(true, 75, 5000, 7500);
//
// Enable AUX power down with LF clock source
// Turn off JTAG domain and enable powerdown - values are default.
//
AONWUCAuxPowerDownConfig(AONWUC_CLOCK_SRC_LF);
AUXWUCPowerCtrl(AUX_WUC_POWER_DOWN);
AONWUCDomainPowerDownEnable();
while(AONWUCPowerStatusGet() & AONWUC_AUX_POWER_ON);
//
// Sync the AON interface to ensure all writes have gone through
//
HWREG(AON_RTC_BASE + AON_RTC_O_SYNC);
//
// Enable transition to power down.
//
PRCMDeepSleep();
}
else
{
//
// Latch the current IO configuration before going to sleep to ensure
// the IOs retain their value even after boot and reset of the
// configuration.
//
AONIOCFreezeEnable();
//
// Turn of all power domains in the MCU voltage domain.
//
PRCMPowerDomainOff(PRCM_DOMAIN_RFCORE | PRCM_DOMAIN_SERIAL |
PRCM_DOMAIN_PERIPH | PRCM_DOMAIN_CPU |
PRCM_DOMAIN_VIMS);
//
// Turn off the MCU voltage domain. This will not take effect until System CPU
// is in deep sleep.
//
PRCMMcuPowerOff();
//
// Set the wake up mode of MCU to immediate
//
AONWUCMcuWakeUpConfig(MCU_IMM_WAKE_UP);
AONWUCMcuPowerOffConfig(MCU_VIRT_PWOFF_DISABLE);
//
// Turn off the AUX domain and wait for power to be off.
//
// Is this required for shutdown mode? or will AUX automatically
// power off.
AUXWUCPowerCtrl(AUX_WUC_POWER_OFF);
while(AONWUCPowerStatusGet() & AONWUC_AUX_POWER_ON)
{ }
//
// Latch the IOs in the padring before going to sleep to retain their
// value even after boot and reset of the configuration.
//
PowerCtrlIOFreezeEnable();
//
// Enable shutdown and make sure the AON interface is in sync on the
// 32kHz clock.
//
AONWUCShutDownEnable();
//
// Sync the AON interface to ensure all writes have gone through
//
HWREG(AON_RTC_BASE + AON_RTC_O_SYNC);
//
// Enable transition to shutdown.
//
PRCMDeepSleep();
}
}
/*
* ======== Power_shutdown ========
*/
Power_Status Power_shutdown(UArg arg)
{
Power_Status status = Power_EFAIL;
Bool exitNow = FALSE;
UInt32 constraints;
UInt hwiKey;
/* make sure shutdown request doesn't violate a constraint */
constraints = Power_getConstraintInfo();
if ((constraints & (Power_SD_DISALLOW)) != 0) {
status = Power_ECHANGE_NOT_ALLOWED;
}
if (status == Power_EFAIL) {
/* make sure Power is not still busy with a previous transition */
hwiKey = Hwi_disable();
if (Power_module->state == Power_ACTIVE) {
/* set new transition state to entering shutdown */
Power_module->state = Power_SHUTDOWN;
}
else {
exitNow = TRUE;
}
Hwi_restore(hwiKey);
if (exitNow == TRUE) {
status = Power_EBUSY;
}
else {
/* disable interrupts as start the shutdown sequence */
Hwi_disable();
/* signal all clients registered for pre-shutdown notification */
status = Power_notify(Power_ENTERING_SHUTDOWN);
/* check for any error */
if (status != Power_SOK) {
Power_module->state = Power_ACTIVE;
CPUcpsie();
return (status);
}
/* proceed with shutdown sequence ... */
/* switch to RCOSC_HF and RCOSC_LF */
OSCInterfaceEnable();
if(OSCClockSourceGet(OSC_SRC_CLK_HF) != OSC_RCOSC_HF) {
OSCClockSourceSet(OSC_SRC_CLK_HF | OSC_SRC_CLK_MF,
OSC_RCOSC_HF);
while(!OSCHfSourceReady());
OSCHfSourceSwitch();
}
OSCClockSourceSet(OSC_SRC_CLK_LF,OSC_RCOSC_LF);
while(OSCClockSourceGet(OSC_SRC_CLK_LF) != OSC_RCOSC_LF);
OSCInterfaceDisable();
/* make sure DMA and CRYTO clocks are off in deep-sleep */
PRCMPeripheralDeepSleepDisable(PRCM_PERIPH_CRYPTO);
PRCMPeripheralDeepSleepDisable(PRCM_PERIPH_UDMA);
PRCMLoadSet();
while(!PRCMLoadGet()){};
/* power OFF AUX and disconnect from bus */
AUXWUCPowerCtrl(AUX_WUC_POWER_OFF);
/* remove AUX force ON */
HWREG(AON_WUC_BASE + AON_WUC_O_AUXCTL) &=
~AON_WUC_AUXCTL_AUX_FORCE_ON;
/*
* reset AON event source IDs to avoid pending events powering
* on MCU/AUX
*/
HWREG(AON_EVENT_BASE + AON_EVENT_O_MCUWUSEL) = 0x3F3F3F3F;
HWREG(AON_EVENT_BASE + AON_EVENT_O_AUXWUSEL) = 0x003F3F3F;
/* sync AON */
HWREG(AON_RTC_BASE + AON_RTC_O_SYNC);
/*
* enable shutdown - this latches the IOs, so configuration of
* IOCFGx registers must be done prior to this
*/
AONWUCShutDownEnable();
/* sync AON */
HWREG(AON_RTC_BASE + AON_RTC_O_SYNC);
/* wait until AUX powered off */
while (AONWUCPowerStatusGet() & AONWUC_AUX_POWER_ON);
/* request to power off MCU when go to deep sleep */
PRCMMcuPowerOff();
/* turn off power domains inside MCU VD (BUS, FL_BUS, RFC, CPU) */
PRCMPowerDomainOff(PRCM_DOMAIN_RFCORE | PRCM_DOMAIN_SERIAL |
PRCM_DOMAIN_PERIPH | PRCM_DOMAIN_CPU | PRCM_DOMAIN_VIMS);
/* deep sleep to activate shutdown */
PRCMDeepSleep();
}
}
Power_module->state = Power_ACTIVE;
/* if get here failed to shutdown, return failure code */
return (Power_EFAIL);
}
int main(void) {
uint8_t payload[ADVLEN];
//Disable JTAG to allow for Standby
AONWUCJtagPowerOff();
//Force AUX on
powerEnableAuxForceOn();
powerEnableRFC();
powerEnableXtalInterface();
// Divide INF clk to save Idle mode power (increases interrupt latency)
powerDivideInfClkDS(PRCM_INFRCLKDIVDS_RATIO_DIV32);
initRTC();
powerEnablePeriph();
powerEnableGPIOClockRunMode();
/* Wait for domains to power on */
while((PRCMPowerDomainStatus(PRCM_DOMAIN_PERIPH) != PRCM_DOMAIN_POWER_ON));
sensorsInit();
ledInit();
//Config IOID4 for external interrupt on rising edge and wake up
//IOCPortConfigureSet(BOARD_IOID_KEY_RIGHT, IOC_PORT_GPIO, IOC_IOMODE_NORMAL | IOC_FALLING_EDGE | IOC_INT_ENABLE | IOC_IOPULL_UP | IOC_INPUT_ENABLE | IOC_WAKE_ON_LOW);
// Config reedSwitch as input
IOCPortConfigureSet(BOARD_IOID_DP0, IOC_PORT_GPIO, IOC_IOMODE_NORMAL | IOC_RISING_EDGE | IOC_INT_ENABLE | IOC_IOPULL_DOWN | IOC_INPUT_ENABLE | IOC_WAKE_ON_HIGH);
//Set device to wake MCU from standby on PIN 4 (BUTTON1)
HWREG(AON_EVENT_BASE + AON_EVENT_O_MCUWUSEL) = AON_EVENT_MCUWUSEL_WU0_EV_PAD; //Does not work with AON_EVENT_MCUWUSEL_WU0_EV_PAD4 --> WHY??
IntEnable(INT_EDGE_DETECT);
powerDisablePeriph();
//Disable clock for GPIO in CPU run mode
HWREGBITW(PRCM_BASE + PRCM_O_GPIOCLKGR, PRCM_GPIOCLKGR_CLK_EN_BITN) = 0;
// Load clock settings
HWREGBITW(PRCM_BASE + PRCM_O_CLKLOADCTL, PRCM_CLKLOADCTL_LOAD_BITN) = 1;
initInterrupts();
initRadio();
// baek: before while
powerEnablePeriph();
powerEnableGPIOClockRunMode();
/* Wait for domains to power on */
while((PRCMPowerDomainStatus(PRCM_DOMAIN_PERIPH) != PRCM_DOMAIN_POWER_ON)); // CRASH !!!!!!!!!!!!!!
sensorsInit();
ledInit();
// end baek:
// Turn off FLASH in idle mode
powerDisableFlashInIdle();
// Cache retention must be enabled in Idle if flash domain is turned off (to avoid cache corruption)
powerEnableCacheRetention();
//AUX - request to power down (takes no effect since force on is set)
powerEnableAUXPdReq();
powerDisableAuxRamRet();
//Clear payload buffer
memset(payload, 0, ADVLEN);
while(1) {
//if((g_count& 0x04)== 1){
rfBootDone = 0;
rfSetupDone = 0;
rfAdvertisingDone = 0;
select_bmp_280(); // activates I2C for bmp-sensor
enable_bmp_280(1); // works
//Wait until RF Core PD is ready before accessing radio
waitUntilRFCReady();
initRadioInts();
runRadio();
//Wait until AUX is ready before configuring oscillators
waitUntilAUXReady();
//Enable 24MHz XTAL
OSCHF_TurnOnXosc();
//IDLE until BOOT_DONE interrupt from RFCore is triggered
while( ! rfBootDone) {
powerDisableCPU();
PRCMDeepSleep();
}
//This code runs after BOOT_DONE interrupt has woken up the CPU again
// ->
//Request radio to keep on system bus
radioCmdBusRequest(true);
//Patch CM0 - no RFE patch needed for TX only
radioPatch();
//Start radio timer
radioCmdStartRAT();
//Enable Flash access while doing radio setup
powerEnableFlashInIdle();
//Switch to XTAL
while( !OSCHF_AttemptToSwitchToXosc())
{}
/* baek: before while
powerEnablePeriph();
powerEnableGPIOClockRunMode();
/* Wait for domains to power on */
/* while((PRCMPowerDomainStatus(PRCM_DOMAIN_PERIPH) != PRCM_DOMAIN_POWER_ON)); // CRASH !!!!!!!!!!!!!!
sensorsInit();
ledInit();
*/
/*****************************************************************************************/
// Read sensor values
uint32_t pressure = 0; // only 3 Bytes used
//uint32_t temp = 0;
select_bmp_280(); // activates I2C for bmp-sensor
enable_bmp_280(1); // works
do{
pressure = value_bmp_280(BMP_280_SENSOR_TYPE_PRESS); // read and converts in pascal (96'000 Pa)
//temp = value_bmp_280(BMP_280_SENSOR_TYPE_TEMP);
}while(pressure == 0x80000000);
if(pressure == 0x80000000){
CPUdelay(100);
pressure = value_bmp_280(BMP_280_SENSOR_TYPE_PRESS); // read and converts in pascal (96'000 Pa)
}
//Start Temp measurement
uint16_t temperature;
enable_tmp_007(1);
//Wait for, read and calc temperature
{
int count = 0;
do{
temperature = value_tmp_007(TMP_007_SENSOR_TYPE_AMBIENT);
//g_count++;
}while( ((temperature == 0x80000000) || (temperature == 0)) && (count <=5) );
count++;
count--;
}
enable_tmp_007(0);
char char_temp[2];
//start hum measurement
configure_hdc_1000();
start_hdc_1000();
// //Wait for, read and calc humidity
while(!read_data_hdc_1000());
int humidity = value_hdc_1000(HDC_1000_SENSOR_TYPE_HUMIDITY);
// char char_hum[5];
//END read sensor values
/*****************************************************************************************/
powerDisablePeriph();
// Disable clock for GPIO in CPU run mode
HWREGBITW(PRCM_BASE + PRCM_O_GPIOCLKGR, PRCM_GPIOCLKGR_CLK_EN_BITN) = 0;
// Load clock settings
HWREGBITW(PRCM_BASE + PRCM_O_CLKLOADCTL, PRCM_CLKLOADCTL_LOAD_BITN) = 1;
/*****************************************************************************************/
// Set payload and transmit
uint8_t p;
p = 0;
/*jedes 5.te mal senden*/
payload[p++] = ADVLEN-1; /* len */
payload[p++] = 0x03;
payload[p++] = 0xde;
payload[p++] = 0xba;
payload[p++] =(sequenceNumber >> 8); // laufnummer
payload[p++] = sequenceNumber;
// Speed
payload[p++] = g_diff >> 24; // higher seconds
payload[p++] = g_diff >> 16; // lower seconds
payload[p++] = g_diff >> 8; // higher subseconds
payload[p++] = g_diff; // lower subseconds
//pressure
payload[p++] = 0;
payload[p++] = 0; //(pressure >> 16);
payload[p++] = 0; //(pressure >> 8);
payload[p++] = 0; //pressure;
//temperature
payload[p++] = 0;
payload[p++] = 0; // char_temp[2];
payload[p++] = 0;//temperature >> 8; // char_temp[1];
payload[p++] = 0; //temperature; //char_temp[0];
// huminity
payload[p++] = 0;
payload[p++] = 0;//char_hum[0];
payload[p++] = 0;//char_hum[1];
payload[p++] = 0;//char_hum[2];
payload[p++] = 0;
payload[p++] = 0;
//Start radio setup and linked advertisment
radioUpdateAdvData(ADVLEN, payload);
//Start radio setup and linked advertisment
radioSetupAndTransmit();
//}
//END: Transmit
/*****************************************************************************************/
//Wait in IDLE for CMD_DONE interrupt after radio setup. ISR will disable radio interrupts
while( ! rfSetupDone) {
powerDisableCPU();
PRCMDeepSleep();
}
//Disable flash in IDLE after CMD_RADIO_SETUP is done (radio setup reads FCFG trim values)
powerDisableFlashInIdle();
//Wait in IDLE for LAST_CMD_DONE after 3 adv packets
while( ! rfAdvertisingDone) {
powerDisableCPU();
PRCMDeepSleep();
}
//Request radio to not force on system bus any more
radioCmdBusRequest(false);
// } // end if
// g_count++;
//
// Standby procedure
//
powerDisableXtal();
// Turn off radio
powerDisableRFC();
// Switch to RCOSC_HF
OSCHfSourceSwitch();
// Allow AUX to turn off again. No longer need oscillator interface
powerDisableAuxForceOn();
// Goto Standby. MCU will now request to be powered down on DeepSleep
powerEnableMcuPdReq();
// Disable cache and retention
powerDisableCache();
powerDisableCacheRetention();
//Calculate next recharge
SysCtrlSetRechargeBeforePowerDown(XOSC_IN_HIGH_POWER_MODE);
// Synchronize transactions to AON domain to ensure AUX has turned off
SysCtrlAonSync();
//
// Enter Standby
//
powerDisableCPU();
PRCMDeepSleep();
SysCtrlAonUpdate();
SysCtrlAdjustRechargeAfterPowerDown();
SysCtrlAonSync();
//
// Wakeup from RTC, code starts execution from here
//
powerEnableRFC();
powerEnableAuxForceOn();
//Re-enable cache and retention
powerEnableCache();
powerEnableCacheRetention();
//MCU will not request to be powered down on DeepSleep -> System goes only to IDLE
powerDisableMcuPdReq();
}
}