Delay functionality. More...

#include <stdint.h>
#include <stdbool.h>

Include dependency graph for delay.h:

This graph shows which files directly or indirectly include this file:

Macros
#define	SYSTICKDELAY 1

#define	ULFRCO 0

Functions
void	delay (uint32_t msDelay)
	Wait for a certain amount of milliseconds in EM2/3. More...

void	sleep (uint32_t sSleep)
	Sleep for a certain amount of seconds in EM2/3. More...

bool	RTC_checkWakeup (void)
	Method to check if the wakeup was caused by the RTC. More...

void	RTC_clearWakeup (void)
	Method to clear `RTC_sleep_wakeup`. More...

uint32_t	RTC_getPassedSleeptime (void)
	Method to get the time spend sleeping (in seconds) in the case of GPIO wake-up. More...

Detailed Description

Delay functionality.

Version: 3.2

Author: Brecht Van Eeckhoudt

License

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

A copy of the GNU General Public License can be found in the LICENSE file along with this source code.

Some methods use code obtained from examples from Silicon Labs' GitHub. These sections are licensed under the Silabs License Agreement. See the file "Silabs_License_Agreement.txt" for details. Before using this software for any purpose, you must agree to the terms of that agreement.

Definition in file delay.h.

Macro Definition Documentation

◆ SYSTICKDELAY

#define SYSTICKDELAY 1

Public definition to select which delay to use

1 - Use SysTick delays.
0 - Use EM2/3 RTC compare delays.

Definition at line 49 of file delay.h.

◆ ULFRCO

#define ULFRCO 0

Public definition to select the use of the crystal or the oscillator

0 - Use the low-frequency crystal oscillator (LFXO), EM2 sleep is used.
1 - Use the ultra low-frequency RC oscillator (ULFRCO), EM3 sleep is used but delays are less precise timing-wise. ** EM3: All unwanted oscillators are disabled, they don't need to manually disabled before EMU_EnterEM3.**

Definition at line 56 of file delay.h.

Function Documentation

◆ delay()

void delay ( uint32_t msDelay )

Wait for a certain amount of milliseconds in EM2/3.

This method also initializes SysTick/RTC if necessary.

Parameters

[in] msDelay The delay time in milliseconds.

Definition at line 116 of file delay.c.

 {
  
 #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 */
  
 }

References dbinfo(), and SysTick_initialized.

Referenced by blink(), ICM_20948_accelGyroCalibrate(), ICM_20948_gyroCalibrate(), ICM_20948_Init(), ICM_20948_Init2(), ICM_20948_lowPowerModeEnter(), ICM_20948_reset(), ICM_20948_reset_mag(), ICM_20948_wakeOnMotionITEnable(), measure_send(), and waitForSlave4().

◆ RTC_checkWakeup()

bool RTC_checkWakeup ( void )

Method to check if the wakeup was caused by the RTC.

Returns: The value of RTC_sleep_wakeup.

Definition at line 396 of file delay.c.

 {
     return (RTC_sleep_wakeup);
 }

◆ RTC_clearWakeup()

void RTC_clearWakeup ( void )

Method to clear RTC_sleep_wakeup.

Definition at line 406 of file delay.c.

 {
     RTC_sleep_wakeup = false;
 }

◆ RTC_getPassedSleeptime()

uint32_t RTC_getPassedSleeptime ( void )

Method to get the time spend sleeping (in seconds) in the case of GPIO wake-up.

Returns: The time spend sleeping in seconds.

Definition at line 420 of file delay.c.

 {
     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);
 }

References LFXOFREQ, and ULFRCOFREQ.

◆ sleep()

void sleep ( uint32_t sSleep )

Sleep for a certain amount of seconds in EM2/3.

This method also initializes the RTC if necessary.