The Power down

Table of Contents

• Power Down introduction
• Power down managing
• Wake-up managing

Power Down operation

SUMMARY:

• Power Down introduction
• Power down managing
• Wake-up managing

Power Down introduction

---

μ-controller power down it's a feature that allows to mitigate disturbances by stopping μ-controller clock. In addition a small save is also obtained in ower consumption. Power Down implementation in our fw is quite flexible: it can be set ON or OFF and the time to wait before power down is active can be also set.
The variable that account for the power down wait is POWER_DOWN_TEMPO_ATTESA. It is reset after any wake up and at startup. It is increased within SysTick_Handler() and is a multiple of 10 ms. Maximum elapsed time before power down is set by the user through POWER_DOWN_MAX_ATTESA. This is done in the main() :

    //COMANDI PER IL POWER_DOWN     
                if (POWER_DOWN_TEMPO_ATTESA >= POWER_DOWN_MAX_ATTESA)                           // Viene incrementato tempo finch\'e non arriva a quel valore
                        {
                    per_non_ripetere = 255;
                    POWER_DOWN_TEMPO_ATTESA=0;
                    if((flag_power_down == true) && POWER_DOWN_ABILITA_CONTEGGIO)                           // Se il flag \'e true, viene attivata la modalit\'a Power Down
                            {
                    // Il micro entra nella modalit\'a Power-down
        //                      POWER_DOWN_ABILITA_CONTEGGIO=0;
                                LED_accendi_spegni(LED_RED, spegni);
                                LED_accendi_spegni(LED_GREEN, spegni);                  
                                LED_remote_ON_OFF();
                                PowerControl_PowerDown();
//                              Pwd_Paolo();
                        }               
                    }

As it can be seen, power down is enabled or not in relation to the 2 boolean variables POWER_DOWN_ABILITA_CONTEGGIO and flag_power_down. The first one, POWER_DOWN_ABILITA_CONTEGGIO, is set false by the fw whenever there is an action into operation. The switch flag_power_down is instead set by the user with the proper instuction, se below.
The function that manages the poower down, invoked above, is PowerControl_PowerDown().

Power down managing

---

Power down to take place needs of a few steps:

• Preparation of the peripheral which will be sensitive to wake up;
• Turn off of all the peripherals that could inhibit the power down to start;
• turn off of the PLL and set the clock to a default;
• Start of power down;
• Operations to be down at wake up: clock, peripherals,...

Our μ-controller has the possibility to be waked-up from the activity on the CAN bus line. However, we encontered some difficulties in exploiting that feature and have used in previous μ-controllers the wake-up from the pin. For doing that the CAN is first disabled, than the receiving pin is set as GPIO input, and enabled as interruput from wake-up, as listed here:

#ifdef power_down_conEINT3
//Questo \'e il powerdown con wake col pin EINT3, di Paolo. L'laternativa sempre valida
 
            // All the RXD pin reconfigurations are implemented as C preprocessor macros
            status = CANdrv ->PowerControl(ARM_POWER_OFF);  //AL risveglio serve per resettare tutti i registri, altrimenti 
            status = CANdrv -> Uninitialize();  
//          NVIC_DisableIRQ(CAN_IRQn);
            PIN_Configure(CAN_RD_PORT, CAN_RD_BIT, PIN_FUNC_0, PIN_PINMODE_TRISTATE, PIN_PINMODE_NORMAL);   // Configure pin as GPIO
            NVIC_DisableIRQ(EINT3_IRQn);    // EINT3 could have been enabled somewhere else
            CAN_INT_F_Enable;                           // Enable GPIO falling edge interrupt
            CAN_INT_Clear;                              // Clear GPIO interrupt 
            NVIC_SetPriority(EINT3_IRQn,31);
            NVIC_SetPriority (SysTick_IRQn, 29); /* set Priority for Systick Interrupt */
            NVIC_ClearPendingIRQ(EINT3_IRQn);           
            NVIC_EnableIRQ(EINT3_IRQn);
            fuffa=0;
 
//Occorre ricordare che la funzione che viene chiamta dall'interupt \'e
// EINT3_IRQHandler();
#endif
 
        I2CAdrv->PowerControl (ARM_POWER_OFF);     // Terminate any pending transfers, reset IRQ/DMA, power off peripheral
        I2CAdrv->Uninitialize ();
        I2CBdrv->PowerControl (ARM_POWER_OFF);     // Terminate any pending transfers, reset IRQ/DMA, power off peripheral
        I2CBdrv->Uninitialize ();
        SPIdrv->PowerControl (ARM_POWER_OFF);     // Terminate any pending transfers, reset IRQ/DMA, power off peripheral
        SPIdrv->Uninitialize ();

As it can be seen, the other communication peripherals used are disabled, too.
The next important step is to disable the PLL of the clock:

    //The SCR (System Control Register) register controls features of entry to and exit from low power modes
    //In order to set the Power Down Mode in the PCON register, it's necessary set to 1 the SLEEPDEEP bit in the scr register
        SCB->SCR |= 4; //(1UL << 2);        // Set SLEEPDEEP, il tipo di powerdown
        LPC_SC->PCON = 0x9;         // 1+8: 1=l'esecuzione di WFI o WFE inizia il power down, se SLEEPDEEP=1, 8=il brown-out \'e disabilitato e non consuma potenza 
 
    //If PLL0 (the main pll) is enabled and connected before etering Deep Sleep or
    //Power-down modes, it will remain enabled and connected afeter the chip enters
    //Deep Sleep or Power-down mode, causing the power consumption to be higher.
    //The code below disable and disconnect PLL0 (See Errata sheet Rev. 10.2)
        
if(mio_PLL0_SETUP){     
        LPC_SC->PLL0CON &= ~(1<<1) ;        //Disconnect the main PLL, il PLL0
        
    //A feed sequence must be written to the PLL0FEED register in order for changes
    //to the PLL0CON and PLL0CFG registers to take effect. 
    //The feed sequence is: 
    //1) write the value 0xAA to PLL0FEED
    //2) write the value 0x55 to PLL0FEED
        
        LPC_SC->PLL0FEED = 0xAA;                //Feed
        LPC_SC->PLL0FEED = 0x55;                //Feed
        
        while ((LPC_SC->PLL0STAT & (1<<25)) != 0x00);           //Wait for PLL0 to disconnect
 
        LPC_SC->PLL0CON &= ~(1<<0);             //Turn off PLL0
        
        LPC_SC->PLL0FEED = 0xAA;
        LPC_SC->PLL0FEED = 0x55;
        
        while ((LPC_SC->PLL0STAT & (1<<24)) != 0x00){}      //Wait PLL0 to shut down
        }

Finally, the μ-controller is ready to sleep:

        if( ( CoreDebug ->DHCSR & 1 )==0 ){ // questo per non fare pasticci se c'e' connesso il debugger                
                __WFI();   //Sonno... (WFI sta per Wait For Interrupt)
    }else{
//      CANActivity_IRQHandler_mio();
//      while(riaccendi_tutto==0);
//              CANActivity_IRQHandler(); //Al risveglio del CAN viene chiamata questa funzione registrata
        while(fuffa==0){
            __NOP();
        }
            }

The switch on CoreDebug ->DHCSR is done to avoid conflict during the debug phase, if the debugger is connected to the JTAG.

Wake-up managing

---

The function EINT3_IRQHandler() is called at the wake-up, when the control room starts the activity on the CAN bus. The first action is to restor the pins dedicated to CAN and the shutting down of the waking interrupt pin in the function WakeResetCAN():

void WakeResetCAN (void)
{
    CAN_INT_F_Disable;
    CAN_INT_Clear;
    NVIC_ClearPendingIRQ(EINT3_IRQn);
    NVIC_DisableIRQ(EINT3_IRQn);        
    PIN_Configure(CAN_RD_PORT, CAN_RD_BIT, CAN_RD_FUNC, PIN_PINMODE_TRISTATE, PIN_PINMODE_NORMAL);
 
}

Finally the clock and all the communication peripherals are re-activated in CANActivity_IRQHandler_mio():

 void  CANActivity_IRQHandler_mio (void){
    
#ifdef power_down_conCAN
        //Queste 3 istruzioni sono necessarie al risveglio
            LPC_SC->CANSLEEPCLR|=2U;  //Il clock viene ri-dato al CAN1
            LPC_CAN1->MOD &=~(1<<4);   //SCrivendo 0 in questo bit si ritorna al normal mode
            LPC_SC->CANWAKEFLAGS|= 2U;  //Reset dell'avvenuto risveglio
            LPC_CAN1->IER &= ~(1<< 4);  //Spegnamo l'interruput da wakeup del CAN
            NVIC_DisableIRQ(CANActivity_IRQn);  //Via anche la chiamata
#endif  
 
            System_init();
 
            I2C_1_Initialize();                                                                 // Viene inizializzata la periferica I2C_A
            I2C_0_Initialize();                                                                 // Viene inizializzata la periferica I2C_B  
            SPI_Inizialize();
 
        // Disable CANActivity interrupt
            LPC_SC->PCON &=~ 0x01;                                      // Reset powerdown mode to idle mode
            SCB->SCR &=~ (1UL << 2);                                    // Reset SLEEPDEEP
            CAN_Inizialize();           // Viene inizializzato il CAN   
            can_clock= CANdrv->GetClock();
//          NVIC_EnableIRQ(CAN_IRQn);
            CANdrv->Control(ARM_CAN_ABORT_MESSAGE_SEND, tx_obj_idx);
            LPC_CAN1->MOD |=1;     //Si annullano tutte le possibili azioni pendenti
            LPC_CAN1->GSR  &= ~CAN_GSR_TXERR_Msk; // Azzeriamo gli errori di trasmissione
            LPC_CAN1->MOD &=~1;    //Si riabilita il CAN    
            uint32_t LPC_dummy= LPC_CAN1->ICR;
            SystemCoreClockUpdate(); 
            rx_msg_info.id = ARM_CAN_EXTENDED_ID(indirizzo_CAN_della_scheda);       // Viene settato l'indirizzo esteso per il messaggio da ricevere    
            fuffa=1;
}

See also

The instruction over the CAN to set the Power Down parametrs is instr_Shut_Down_ON_OFF.