Power_down.c

Go to the documentation of this file.

 
 
 
#include "tutti_gli_header.h"
#include "RTE_Device.h"
#include "core_cm3.h"
 
 
// DOCUMENTAZIONE DOXYGEN
 
/// \file
 
/*! \page Power_down  The Power down
\anchor Power_down_ref
*\brief  <span style="color:red;"> <b> Power Down operation  </b> </span>
*\tableofcontents
 
 \b SUMMARY:
*\arg \ref introduction_to_Power_down
*\arg  \ref Power_down_managing
*\arg \ref Wake_up_managing
 
*\section introduction_to_Power_down Power Down introduction
<hr width="90%" size="10" align="left">
\n &mu;-controller power down it's a feature that allows to mitigate disturbances by stopping &mu;-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.
\n 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 \b 10 \b ms. Maximum elapsed time before power down is 
set by the user through #POWER_DOWN_MAX_ATTESA. This is done in the main() :
 
*\snippet{lineno} main_for_CROSS_FrontEnd.c fun_power_down_main
 
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.
\n The function that manages the poower down, invoked above, is PowerControl_PowerDown().
 
*\section Power_down_managing Power down managing
<hr width="90%" size="10" align="left">
\n 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,...
 
\n Our &mu;-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 
&mu;-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:
 
*\snippet{lineno} Power_down.c code_PowerDown_int_enable
 
As it can be seen, the other communication peripherals used are disabled, too.
\n The next important step is to disable the PLL of the clock:
 
*\snippet{lineno} Power_down.c code_PowerDown_clock_disable
 
Finally, the &mu;-controller is ready to sleep:
 
*\snippet{lineno} Power_down.c code_PowerDown_sleep_set
 
The switch on \b CoreDebug ->DHCSR is done to avoid conflict during the debug phase, 
if the debugger is connected to the JTAG.
 
*\section Wake_up_managing Wake-up managing
<hr width="90%" size="10" align="left">
 
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():
 
*\snippet{lineno} Power_down.c fun_PowerControl_CAN_restoring
 
Finally the clock and all the communication peripherals are re-activated in CANActivity_IRQHandler_mio():
 
*\snippetlineno Power_down.c   fun_PowerControl_wake_up_peripherals
 
\sa The instruction over the CAN to set the Power Down parametrs is \ref instr_Shut_Down_ON_OFF_option "instr_Shut_Down_ON_OFF".
 
*/ 
uint32_t                                                tempo = 0U;  
uint8_t volatile fuffa=0;
volatile        uint32_t can_clock;
 
#define power_down_conEINT3
//#define power_down_conCAN
 
//#define CLOCK_SETUP           1                                           //Definizioni per il System_Init()
//#define SCS_Val               0x00000020
//#define CLKSRCSEL_Val         0x00000001
//#define PLL0CFG_Val           0x00050063 
//#define CCLKCFG_Val           0x00000003
//#define PCLKSEL0_Val          0x00000000
//#define PCLKSEL1_Val          0x00000000
 
 
 
#define LPC_CAN             (LPC_CAN1)
 
#define CAN_RD_PORT     (RTE_CAN1_RD_PORT)
#define CAN_RD_BIT      (RTE_CAN1_RD_BIT)
#define CAN_RD_FUNC     (RTE_CAN1_RD_FUNC)
 
#define CAN_TD_PORT     (RTE_CAN1_TD_PORT)
#define CAN_TD_BIT      (RTE_CAN1_TD_BIT)
 
#define CAN_INT_F_Enable    ((CAN_RD_PORT == 0) ? (LPC_GPIOINT->IO0IntEnF |= (1 << CAN_RD_BIT)) : (LPC_GPIOINT->IO2IntEnF |= (1 << CAN_RD_BIT)))
#define CAN_INT_F_Disable   ((CAN_RD_PORT == 0) ? (LPC_GPIOINT->IO0IntEnF &= ~(1 << CAN_RD_BIT)) : (LPC_GPIOINT->IO2IntEnF &= ~(1 << CAN_RD_BIT)))
#define CAN_INT_Clear           ((CAN_RD_PORT == 0) ? (LPC_GPIOINT->IO0IntClr |= (1 << CAN_RD_BIT)) : (LPC_GPIOINT->IO2IntClr |= (1 << CAN_RD_BIT)))
#define CAN_INT_Status    ((CAN_RD_PORT == 0) ? ((LPC_GPIOINT->IO0IntStatF & (1 << CAN_RD_BIT)) != 0) : ((LPC_GPIOINT->IO2IntStatF & (1 << CAN_RD_BIT)) != 0))
 
volatile uint32_t POWER_DOWN_TEMPO_ATTESA=0; //!< Counter to wait for power down, multiple of 10 ms
 
volatile uint32_t POWER_DOWN_MAX_ATTESA=5000; //!< upper limit for POWER_DOWN_TEMPO_ATTESA
 
volatile uint32_t POWER_DOWN_ABILITA_CONTEGGIO=0; //!< Power down couter and anable is set if this variable is true
 
//typedef enum
//{
//  EXTI_EINT0 = 0, 
//  EXTI_EINT1 = 1, 
//  EXTI_EINT2 = 2, 
//  EXTI_EINT3 = 3       
//} EXTI_LINE_ENUM;
 
//typedef enum
//{
//  EXTI_MODE_LEVEL_SENSITIVE,      
//  EXTI_MODE_EDGE_SENSITIVE        
//} EXTI_MODE_ENUM;
 
//typedef enum
//{
//  EXTI_POLARITY_LOW_ACTIVE_OR_FALLING_EDGE = 1,       
//  EXTI_POLARITY_HIGH_ACTIVE_OR_RISING_EDGE = 0        
//} EXTI_POLARITY_ENUM;
 
//typedef struct
//{
//  EXTI_LINE_ENUM EXTI_Line; 
//  EXTI_MODE_ENUM EXTI_Mode; 
//  EXTI_POLARITY_ENUM EXTI_Polarity; 
//} EXTI_InitTypeDef;
 
/*****************************************************************************
  Funzione che rigenera il PLL0
 ******************************************************************************/
void System_init(void)
{
    
    //ATTENZIONE: le macro XXX_Val sono costruite dal configuration wizard
        LPC_SC->SCS       = mio_SCS_Val;  //Abilitazione main oscillator
        if (LPC_SC->SCS & (1 << 5)) {             /* If Main Oscillator is enabled  */
            while ((LPC_SC->SCS & (1<<6)) == 0);/* Main oscillator status, Wait for Oscillator to be ready, quando diventa 1   */
        }
 
        LPC_SC->CCLKCFG   = mio_CCLKCFG_Val;      /* Setup Clock Divider                */
        /* Periphral clock must be selected before PLL0 enabling and connecting
        * - according errata.lpc1768-16.March.2010 -
        */
        LPC_SC->PCLKSEL0  = mio_PCLKSEL0_Val;     /* Peripheral Clock Selection         */
        LPC_SC->PCLKSEL1  = mio_PCLKSEL1_Val;
 
        LPC_SC->CLKSRCSEL = mio_CLKSRCSEL_Val;    /* Select Clock Source sysclk / PLL0  */
        LPC_SC->PLL0CFG   = mio_PLL0CFG_Val;      /* configure PLL0                     */
        LPC_SC->PLL0FEED  = 0xAA;
        LPC_SC->PLL0FEED  = 0x55;
    
        LPC_SC->PLL0CON   = mio_PLL0_SETUP;//0x01;             /* PLL0 Enable                        */
        LPC_SC->PLL0FEED  = 0xAA;
        LPC_SC->PLL0FEED  = 0x55;
    if(mio_PLL0_SETUP){     
        while (!(LPC_SC->PLL0STAT & (1<<26)));/* Wait for PLOCK0                    */
 
 
        LPC_SC->PLL0CON   = 0x03;             /* PLL0 Enable & Connect              */
        LPC_SC->PLL0FEED  = 0xAA;
        LPC_SC->PLL0FEED  = 0x55;
        while ((LPC_SC->PLL0STAT & ((1<<25) | (1<<24))) != ((1<<25) | (1<<24)));  /* Wait for PLLC0_STAT & PLLE0_STAT */
    }
    // Configurazione del Timer
        SystemCoreClockUpdate();                                        // Viene aggiornato il system core clock         
        SysTick_Config(SystemCoreClock/1000);                       // Viene generato l'interrupt ogni 1    
//      SysTick->CTRL  &= ~SysTick_CTRL_ENABLE_Msk;
        NVIC_SetPriority (SysTick_IRQn, 29); /* set Priority for Systick Interrupt */
//      SysTick->CTRL  |= SysTick_CTRL_ENABLE_Msk;
}
// void  CANActivity_IRQHandler (void){
//   
//   CANActivity_IRQHandler_mio();
// }
 
 
 /*****************************************************************************
    Interrupt che viene chiamato subito dopo il risveglio
 ******************************************************************************/
 
/*! \brief Peripherals Wake-up
 
*\param[in,out] no param
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Power_down.c   fun_PowerControl_wake_up_peripherals
*/
//! <!-- [fun_PowerControl_wake_up_peripherals] -->
 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;
}
 //! <!-- [fun_PowerControl_wake_up_peripherals] -->
 
 /*****************************************************************************
    Funzione che disabilita e spegne il PLL0
 ******************************************************************************/
//void PLL0_Stop_Sequence (void)
//{
////#if (PLL0_SETUP)
//  LPC_SC->PLL0CON &= ~(1<<1);                                                                 //Viene disconnesso il PLL principale
//  LPC_SC->PLL0FEED = 0xAA;                                                                        //Feed
//  LPC_SC->PLL0FEED = 0x55;                                                                        //Feed
//      
//  while ((LPC_SC->PLL0STAT & (1<<25)) != 0x00);                               //Si attendi finch\'e il PLL non viene disconnesso
 
//  LPC_SC->PLL0CON &= ~(1<<0);                                                                 // Viene spento il PLL0
//      
//  LPC_SC->PLL0FEED = 0xAA;
//  LPC_SC->PLL0FEED = 0x55;
//      
//  while ((LPC_SC->PLL0STAT & (1<<24)) != 0x00) {}                         //Si aspetta il PLL0 per spegnere
////#endif
//}
 
 
/*! \brief Power down managing function
 
*\param[in,out] no param
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Power_down.c   fun_PowerControl_PowerDown
*/
//! <!-- [fun_PowerControl_PowerDown] -->
void PowerControl_PowerDown(void)
{
    //The CCLKCFG register controls the division of the PLL0 output before it is used by the CPU. 
    //When PLL0 is bypassed, the division may be by 1.
    //When PLL0 is running, the output must be divide in order to bring the CPU clock frequency (CCLK) within operating limits.
//      int CAN_IER_BUFFER=LPC_CAN1->IER; //Ci ricordiamo delle sorgenti di interrupt perch\'e si perdono e l'inizializzazione non le reassegna
      
//      int CCLKDIV = LPC_SC->CCLKCFG;      
    
//      int PLLMULT = LPC_SC->PLL0CFG; //The PLL0CFG register contains PLL0 multiplier and divider value.
 
#ifdef power_down_conCAN
    //Questo \'e ilpowerdown con wakeup col CAN: mai che funzioni
        LPC_CAN1->MOD |=1;     //Si annullano tutte le possibili azioni pendenti
        LPC_CAN1->IER = 1<< 4; // Abilito WUIE: l'interrupt del CAN per il wakeup
        LPC_CAN1->MOD &=~1;    //Si riabilita il CAN
        
        NVIC_ClearPendingIRQ(CANActivity_IRQn);
        NVIC_ClearPendingIRQ(CAN_IRQn);
        #define CAN_PORT 1
        while ((LPC_SC->CANWAKEFLAGS>>CAN_PORT) & 0x01)  //Ci si assicura che non ci siano wakeup in corso e si aspetta che finiscano, eventualmente
        LPC_SC->CANWAKEFLAGS |= (1<<CAN_PORT);  //Ora si resettano le possbili attivit\'a
        LPC_CAN1->MOD |=(1<<4);
//      LPC_CAN1->IER = 1<< 4; // Abilito WUIE: l'interrupt del CAN per il wakeup   
        NVIC_SetPriority(CANActivity_IRQn,31);
        NVIC_SetPriority (SysTick_IRQn, 29); /* set Priority for Systick Interrupt */
        NVIC_EnableIRQ(CANActivity_IRQn); //Abilitiamo il CAN come sorgente di interrupt di risveglio   
#endif
//! <!-- [code_PowerDown_int_enable] -->
#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 ();
//! <!-- [code_PowerDown_int_enable] -->
 
//! <!-- [code_PowerDown_clock_disable] -->
    //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
        }
//! <!-- [code_PowerDown_clock_disable] --> 
 
    // Execution of the WFI instruction will cause immediate entry to any of the four reduced 
    // power modes based on the SLEEPDEEP bit and PCON Register settings.
            //SysTick->CTRL &= ~1;  //Spegnamo il systick counter
//! <!-- [code_PowerDown_sleep_set] -->     
        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();
        }
            }
//! <!-- [code_PowerDown_sleep_set] -->
 
//      LPC_CAN1->IER=CAN_IER_BUFFER;//Ristabiliamo tutte le sorgenti di interruzione del CAN
}
//! <!-- [fun_PowerControl_PowerDown] -->
 
 
/*! \brief CAN pins restoring
 
*\param[in,out] no param
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Power_down.c   fun_PowerControl_CAN_restoring
*/
//! <!-- [fun_PowerControl_CAN_restoring] -->
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);
 
}
//! <!-- [fun_PowerControl_CAN_restoring] -->
 
 
//void EXTI_ClearEXTIFlag(EXTI_LINE_ENUM EXTILine)
//{
//  LPC_SC->EXTINT |= (1 << EXTILine);
//}
 
/*! \brief Wake-up managing function
 
*\param[in,out] no param
*\return   No Parameters, the actual result is sent to the CAN bus output throught \ref tx_data.
 
*\snippetlineno Power_down.c   fun_PowerControl_wake_up
*/
//! <!-- [fun_PowerControl_wake_up] -->
void EINT3_IRQHandler (void)
{
#define risveglio_di_Paolo
#define risveglio_di_gianluigi
#ifdef  risveglio_di_Paolo
    WakeResetCAN();  //Il pin ritorna ad essere CAN
#endif
#ifdef  risveglio_di_gianluigi
    CANActivity_IRQHandler_mio();
#endif
    LED_accendi_spegni(LED_RED, accendi);
}
//! <!-- [fun_PowerControl_wake_up] -->
 
//void EXTI_SetMode(EXTI_LINE_ENUM EXTILine, EXTI_MODE_ENUM mode)
//{
//  if (mode == EXTI_MODE_EDGE_SENSITIVE)
//  {
//      LPC_SC->EXTMODE |= (1 << EXTILine);
//  }
//  else if (mode == EXTI_MODE_LEVEL_SENSITIVE)
//  {
//      LPC_SC->EXTMODE &= ~(1 << EXTILine);
//  }
//}
 
/*********************************************************************/
//void EXTI_SetPolarity(EXTI_LINE_ENUM EXTILine, EXTI_POLARITY_ENUM polarity)
//{
//  if (polarity == EXTI_POLARITY_HIGH_ACTIVE_OR_RISING_EDGE)
//  {
//      LPC_SC->EXTPOLAR |= (1 << EXTILine);
//  }
//  else if (polarity == EXTI_POLARITY_LOW_ACTIVE_OR_FALLING_EDGE)
//  {
//      LPC_SC->EXTPOLAR &= ~(1 << EXTILine);
//  }
//}
 
//void EXTI_SetPin (EXTI_LINE_ENUM EXTILine)
//{
//  LPC_PINCON->PINSEL4 &=~     (0x3 << (20 + EXTILine*2));
//  LPC_PINCON->PINSEL4 |=      (0x1 << (20 + EXTILine*2));
//  LPC_PINCON->PINMODE4 &=~    (0x3 << (20 + EXTILine*2));
//}
 
//void EXTI_Config(EXTI_InitTypeDef *EXTICfg)
//{
//  //LPC_SC->EXTINT = 0x0;
//  EXTI_SetMode(EXTICfg->EXTI_Line, EXTICfg->EXTI_Mode);
//  EXTI_SetPolarity(EXTICfg->EXTI_Line, EXTICfg->EXTI_Polarity);
//  EXTI_SetPin(EXTICfg->EXTI_Line);
//}
 
//void Pwd_Paolo (void) {
//      
//          //EXTI_InitTypeDef  EXTI_InitStruct;
//  
//          //EXTI_InitStruct.EXTI_Line = EXTI_EINT3;
//          //EXTI_InitStruct.EXTI_Mode = EXTI_MODE_EDGE_SENSITIVE;
//          //EXTI_InitStruct.EXTI_Polarity = EXTI_POLARITY_LOW_ACTIVE_OR_FALLING_EDGE;
 
//          //EXTI_Config(&EXTI_InitStruct);        // Init EINT3
//          SCB->SCR |= 4; //(1UL << 2);        // Set SLEEPDEEP
//          LPC_SC->PCON = 0x9;         // Set powerdown mode
 
//          
//                  
//          LPC_CAN->MOD |= 0x01;       // Switch off can
////            LPC_CAN1->IER =0;
//           
//          // All the RXD pin reconfigurations are implemented as C preprocessor macros 
//          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
//          
//          // Clear and (re-)enable GPIO interrupt
//              
////  NVIC_DisableIRQ(EINT0_IRQn);    // Disable EINT0 interrupt avoiding unintentional wakeup
////    NVIC_DisableIRQ(EINT2_IRQn);      // Disable EINT2 interrupt avoiding unintentional wakeup
////  NVIC_DisableIRQ(EINT3_IRQn);    // Disable EINT3 interrupt avoiding unintentional wakeup
////    NVIC_DisableIRQ(SPI_IRQn);    // Disable UART0 interrupt avoiding unintentional wakeup
////    NVIC_DisableIRQ(I2C0_IRQn);       // Disable I2C0 interrupt
////    NVIC_DisableIRQ(I2C1_IRQn);       // Disable I2C1 interrupt
////    NVIC_DisableIRQ(I2C2_IRQn);       // Disable I2C2 interrupt
////    NVIC_DisableIRQ(CAN_IRQn);        // Disable CAN interrupt
 
//          
//          
//          NVIC_ClearPendingIRQ(EINT3_IRQn);
//          NVIC_EnableIRQ(EINT3_IRQn);
//          
//          
//          
//          // If PLL0 (the main pll) is enabled and connected before etering Deep Sleep or
//          // Powerdown modes, it will remain enabled and connected after the chip enters
//          // Deep Sleep or Powerdown mode, causing the power consumption to be higher.
//          // The code below disable and disconnect PLL0 (See Errata sheet Rev. 10.2)
//          PLL0_Stop_Sequence();
//          
//          // These instructions were suggested by Lorenzo but it seems that it works also 
//          // without them at 100 kbit (1 Mbit might cause problems)
////            LPC_SC->PCLKSEL0 |= (0x54000000);   // Sets peripheral divider to 1 for CAN1, CAN2 and CAN_Filters
////            LPC_SC->CCLKCFG &= ~(0xFF);             // Sets clock divider to 1
//          // PLL0_Start_Sequence (after power-down) sets the values back to normal
//                                          // Set LEDs to powerdown mode (green LED)   
//          if ((CoreDebug->DHCSR & 1) == 0) {  // Check C_DEBUGEN
//          // Debugger disconnected, enter powerdown
//              __WFE();                                                    // Enter powerdown mode
//              
//          }   else{               // Reset LEDs to active mode (red LED)
//              EINT3_IRQHandler();
//          }
 
////    EINT3_IRQHandler();
//          // PLL0 re-initialization. This function uses the options set in system_LPC17xx.c Configuration Wizard              
////            NVIC_DisableIRQ(EINT3_IRQn);
////            CAN_Inizialize();
//          System_init();
//          LPC_SC->PCON &=~ 0x01;                                      // Reset powerdown mode to idle mode
//          SCB->SCR &=~ (1UL << 2);                                    // Reset SLEEPDEEP
//  CAN_Inizialize();       // Viene inizializzata la periferica CAN
//  rx_msg_info.id = ARM_CAN_EXTENDED_ID(indirizzo_CAN_della_scheda);
////    NVIC_EnableIRQ(CAN_IRQn);
////    SPI_Inizialize();                                                                       // Viene inizializzata la periferica SPI
////    I2C_1_Initialize();                                                                 // Viene inizializzata la periferica I2C_A
////    I2C_0_Initialize();                                                                 // Viene inizializzata la periferica I2C_B  
////    I2C_termometro_Initialize();                                                // Viene inizializzata la periferica I2C_termometro_Inizialize
 
//}