delay.c

Go to the documentation of this file.

/***************************************************************************/
#include <stdint.h>        /* (u)intXX_t */
#include <stdbool.h>       /* "bool", "true", "false" */
#include "em_device.h"     /* Include necessary MCU-specific header file */
#include "em_cmu.h"        /* Clock management unit */
#include "em_emu.h"        /* Energy Management Unit */
#include "em_gpio.h"       /* General Purpose IO */
#include "em_rtc.h"        /* Real Time Counter (RTC) */
 
#include "delay.h"         /* Corresponding header file */
//#include "pin_mapping.h"   /* PORT and PIN definitions */
#include "debug_dbprint.h" /* Enable or disable printing to UART */
//#include "util.h"        /* Utility functionality */
 
 
/* Local definitions (for RTC compare interrupts) */
#define ULFRCOFREQ    1000
#define ULFRCOFREQ_MS 1.000
#define LFXOFREQ      32768
#define LFXOFREQ_MS   32.768
 
 
/* Local variables */
/*   -> Volatile because it's modified by an interrupt service routine (@RAM)
 *   -> Static so it's always kept in memory (@data segment, space provided during compile time) */
static volatile bool RTC_sleep_wakeup = false;
 
#if SYSTICKDELAY == 1 /* SysTick delay selected */
static volatile uint32_t msTicks;
#endif /* SysTick/RTC selection */
 
 
bool sleeping = false;
bool RTC_initialized = false;
 
#if SYSTICKDELAY == 1 /* SysTick delay selected */
bool SysTick_initialized = false;
#endif /* SysTick/RTC selection */
 
 
/* Local prototype */
static void initRTC (void);
 
 
/**************************************************************************/
void delay (uint32_t msDelay)
{
 
#if SYSTICKDELAY == 1 /* SysTick delay selected */
 
    /* Initialize SysTick if not already the case */
    if (!SysTick_initialized)
    {
        /* Initialize and start SysTick
         * Number of ticks between interrupt = cmuClock_CORE/1000 */
        if (SysTick_Config(CMU_ClockFreqGet(cmuClock_CORE) / 1000)) while (1);
 
#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
    dbinfo("SysTick initialized");
#endif /* DEBUG_DBPRINT */
 
        SysTick_initialized = true;
    }
    else
    {
        /* Enable SysTick interrupt and counter by setting their bits. */
        SysTick->CTRL |= SysTick_CTRL_TICKINT_Msk | SysTick_CTRL_ENABLE_Msk;
    }
 
    /* Wait a certain amount of ticks */
    uint32_t curTicks = msTicks;
    while ((msTicks - curTicks) < msDelay);
 
    /* Disable SysTick interrupt and counter (needs to be done before entering EM2/3) by clearing their bits. */
    SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk & ~SysTick_CTRL_ENABLE_Msk;
 
#else /* EM2/3 RTC delay selected */
 
 
    /* Initialize RTC if not already the case */
    if (!RTC_initialized) initRTC();
    else
    {
        /* Enable necessary oscillator and clocks */
 
#if ULFRCO == 1 /* ULFRCO selected */
 
        /* No specific code here */
 
#else /* LFXO selected */
 
        /* Enable the low-frequency crystal oscillator for the RTC */
        //CMU_OscillatorEnable(cmuOsc_LFXO, true, true);
 
#endif /* ULFRCO/LFXO selection */
 
        /* Enable the clock to the interface of the low energy modules
         * cmuClock_CORELE = cmuClock_HFLE (deprecated) */
        //CMU_ClockEnable(cmuClock_HFLE, true);
 
        /* Turn on the RTC clock */
        CMU_ClockEnable(cmuClock_RTC, true);
    }
 
    /* Set RTC compare value for RTC compare register 0 depending on ULFRCO/LFXO selection */
 
#if ULFRCO == 1 /* ULFRCO selected */
 
    if ((ULFRCOFREQ_MS * msDelay) <= 0x00ffffff) RTC_CompareSet(0, (ULFRCOFREQ_MS * msDelay));
    else
    {
 
#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Delay too long, can't fit in the field!");
#endif /* DEBUG_DBPRINT */
 
        /* Turn off the RTC clock */
        CMU_ClockEnable(cmuClock_RTC, false);
 
        //error(14);
 
        /* Exit function */
        return;
    }
 
#else /* LFXO selected */
 
    if ((LFXOFREQ_MS * msDelay) <= 0x00ffffff) RTC_CompareSet(0, (LFXOFREQ_MS * msDelay));
    else
    {
 
#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Delay too long, can't fit in the field!");
#endif /* DEBUG_DBPRINT */
 
        /* Turn off the RTC clock */
        CMU_ClockEnable(cmuClock_RTC, false);
 
        //error(15);
 
        /* Exit function */
        return;
    }
 
#endif /* ULFRCO/LFXO selection */
 
 
    /* Start the RTC */
    RTC_Enable(true);
 
    /* Enter EM2/3 depending on ULFRCO/LFXO selection */
 
#if ULFRCO == 1 /* ULFRCO selected */
    /* In EM3, high and low frequency clocks are disabled. No oscillator (except the ULFRCO) is running.
     * Furthermore, all unwanted oscillators are disabled in EM3. This means that nothing needs to be
     * manually disabled before the statement EMU_EnterEM3(true); */
    EMU_EnterEM3(true); /* "true" - Save and restore oscillators, clocks and voltage scaling */
#else /* LFXO selected */
    EMU_EnterEM2(true); /* "true" - Save and restore oscillators, clocks and voltage scaling */
#endif /* ULFRCO/LFXO selection */
 
 
    /* Disable used oscillator and clocks after wake-up */
 
#if ULFRCO == 1 /* ULFRCO selected */
 
    /* No specific code here */
 
#else /* LFXO selected */
 
    /* Disable the low-frequency crystal oscillator for the RTC */
    //CMU_OscillatorEnable(cmuOsc_LFXO, false, true);
 
#endif /* ULFRCO/LFXO selection */
 
    /* Disable the clock to the interface of the low energy modules
     * cmuClock_CORELE = cmuClock_HFLE (deprecated) */
    //CMU_ClockEnable(cmuClock_HFLE, false);
 
    /* Turn off the RTC clock */
    CMU_ClockEnable(cmuClock_RTC, false);
 
#endif /* SysTick/RTC selection */
 
}
 
 
/**************************************************************************/
void sleep (uint32_t sSleep)
{
    /* Initialize RTC if not already the case */
    if (!RTC_initialized) initRTC();
    else
    {
        /* Enable necessary oscillator and clocks */
 
#if ULFRCO == 1 /* ULFRCO selected */
 
        /* No specific code here */
 
#else /* LFXO selected */
 
        /* Enable the low-frequency crystal oscillator for the RTC */
        //CMU_OscillatorEnable(cmuOsc_LFXO, true, true);
 
#endif /* ULFRCO/LFXO selection */
 
        /* Enable the clock to the interface of the low energy modules
         * cmuClock_CORELE = cmuClock_HFLE (deprecated) */
        //CMU_ClockEnable(cmuClock_HFLE, true);
 
        /* Turn on the RTC clock */
        CMU_ClockEnable(cmuClock_RTC, true);
    }
 
#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
#if ULFRCO == 1 /* ULFRCO selected */
    dbwarnInt("Sleeping in EM3 for ", sSleep, " s\n\r");
#else /* LFXO selected */
    dbwarnInt("Sleeping in EM2 for ", sSleep, " s\n\r");
#endif /* ULFRCO/LFXO selection */
#endif /* DEBUG_DBPRINT */
 
    /* Set RTC compare value for RTC compare register 0 depending on ULFRCO/LFXO selection */
 
#if ULFRCO == 1 /* ULFRCO selected */
 
    if ((ULFRCOFREQ * sSleep) <= 0x00ffffff) RTC_CompareSet(0, (ULFRCOFREQ * sSleep));
    else
    {
 
#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Delay too long, can't fit in the field!");
#endif /* DEBUG_DBPRINT */
 
        /* Turn off the RTC clock */
        CMU_ClockEnable(cmuClock_RTC, false);
 
        //error(16);
 
        /* Exit function */
        return;
    }
 
#else /* LFXO selected */
 
    if ((LFXOFREQ * sSleep) <= 0x00ffffff) RTC_CompareSet(0, (LFXOFREQ * sSleep));
    else
    {
 
#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Delay too long, can't fit in the field!");
#endif /* DEBUG_DBPRINT */
 
        /* Turn off the RTC clock */
        CMU_ClockEnable(cmuClock_RTC, false);
 
        error(17);
 
        /* Exit function */
        return;
    }
 
#endif /* ULFRCO/LFXO selection */
 
    /* Indicate that we're using the sleep method */
    sleeping = true;
 
 
    /* Start the RTC */
    RTC_Enable(true);
 
    /* Enter EM2/3 depending on ULFRCO/LFXO selection */
 
#if ULFRCO == 1 /* ULFRCO selected */
    /* In EM3, high and low frequency clocks are disabled. No oscillator (except the ULFRCO) is running.
     * Furthermore, all unwanted oscillators are disabled in EM3. This means that nothing needs to be
     * manually disabled before the statement EMU_EnterEM3(true); */
    EMU_EnterEM3(true); /* "true" - Save and restore oscillators, clocks and voltage scaling */
#else /* LFXO selected */
    EMU_EnterEM2(true); /* "true" - Save and restore oscillators, clocks and voltage scaling */
#endif /* ULFRCO/LFXO selection */
 
 
    /* Indicate that we're no longer sleeping */
    sleeping = false;
 
    /* Disable used oscillator and clocks after wake-up */
 
#if ULFRCO == 1 /* ULFRCO selected */
 
    /* No specific code here */
 
#else /* LFXO selected */
 
    /* Disable the low-frequency crystal oscillator for the RTC */
    //CMU_OscillatorEnable(cmuOsc_LFXO, false, true);
 
#endif /* ULFRCO/LFXO selection */
 
    /* Disable the clock to the interface of the low energy modules
     * cmuClock_CORELE = cmuClock_HFLE (deprecated) */
    //CMU_ClockEnable(cmuClock_HFLE, false);
 
    /* Turn off the RTC clock */
    CMU_ClockEnable(cmuClock_RTC, false);
}
 
 
/**************************************************************************/
bool RTC_checkWakeup (void)
{
    return (RTC_sleep_wakeup);
}
 
 
/**************************************************************************/
void RTC_clearWakeup (void)
{
    RTC_sleep_wakeup = false;
}
 
 
/**************************************************************************/
uint32_t RTC_getPassedSleeptime (void)
{
    uint32_t sSleep = RTC_CounterGet();
 
    /* Disable the counter */
    RTC_Enable(false);
 
#if ULFRCO == 1 /* ULFRCO selected */
        sSleep /= ULFRCOFREQ;
#else /* LFXO selected */
        sSleep /= LFXOFREQ;
#endif /* ULFRCO/LFXO selection */
 
    return (sSleep);
}
 
 
/**************************************************************************/
static void initRTC (void)
{
 
#if ULFRCO == 1 /* ULFRCO selected */
 
    /* Enable the ultra low-frequency RC oscillator for the RTC */
    //CMU_OscillatorEnable(cmuOsc_ULFRCO, true, true); /* The ULFRCO is always on */
 
    /* Enable the clock to the interface of the low energy modules
     * cmuClock_CORELE = cmuClock_HFLE (deprecated) */
    CMU_ClockEnable(cmuClock_HFLE, true);
 
    /* Route the ULFRCO clock to the RTC */
    CMU_ClockSelectSet(cmuClock_LFA, cmuSelect_ULFRCO);
 
#else /* LFXO selected */
 
    /* Enable the low-frequency crystal oscillator for the RTC */
    CMU_OscillatorEnable(cmuOsc_LFXO, true, true);
 
    /* Enable the clock to the interface of the low energy modules
     * cmuClock_CORELE = cmuClock_HFLE (deprecated) */
    CMU_ClockEnable(cmuClock_HFLE, true);
 
    /* Route the LFXO clock to the RTC */
    CMU_ClockSelectSet(cmuClock_LFA, cmuSelect_LFXO);
 
#endif /* ULFRCO/LFXO selection */
 
    /* Turn on the RTC clock */
    CMU_ClockEnable(cmuClock_RTC, true);
 
    /* Allow channel 0 to cause an interrupt */
    RTC_IntEnable(RTC_IEN_COMP0);
    RTC_IntClear(RTC_IFC_COMP0); /* This statement was in the ULFRCO but not in the LFXO example. It's kept here just in case. */
    NVIC_ClearPendingIRQ(RTC_IRQn);
    NVIC_EnableIRQ(RTC_IRQn);
 
    /* Configure the RTC settings */
    RTC_Init_TypeDef rtc = RTC_INIT_DEFAULT;
    rtc.enable = false; /* Don't start counting when initialization is done */
 
    /* Initialize RTC with pre-defined settings */
    RTC_Init(&rtc);
 
#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
#if ULFRCO == 1 /* ULFRCO selected */
    dbinfo("RTC initialized with ULFRCO\n\r");
#else /* LFXO selected */
    dbinfo("RTC initialized with LFXO\n\r");
#endif /* ULFRCO/LFXO selection */
#endif /* DEBUG_DBPRINT */
 
    RTC_initialized = true;
}
 
 
#if SYSTICKDELAY == 1 /* SysTick delay selected */
/**************************************************************************/
void SysTick_Handler (void)
{
    msTicks++; /* Increment counter necessary by SysTick delay functionality */
}
#endif /* SysTick/RTC selection */
 
 
/**************************************************************************/
//void RTC_IRQHandler (void)
//{
    /* Disable the counter */
    //RTC_Enable(false);
 
    /* Clear the interrupt source */
    //RTC_IntClear(RTC_IFC_COMP0);
 
    /* If the wakeup was caused by "sleeping" (not a delay), act accordingly */
    //if (sleeping) RTC_sleep_wakeup = true;
//}