Call a function every 10 seconds in C - mbed platform - c

Question

I could use:
while(1==1)
{
delay(10);
f(); // <-- function to be called every 10 seconds
otherfunctions();
}
But this will take just over 10 seconds because the other functions take some time to execute. Is there a delay function that takes into account the time taken by the other functions so I can then call f() exactly every 10 seconds?
I've heard that this can be done with a clever function that can be found in a header file, but I cant remember which one. I think it might have been #include mbed.h but even if the function is included in this header file I do not know what it is called or how to search for it.
Does anybody know of a function that can do what I am after?

Answer 1

You should of course start by reading the mbed handbook. It is not a large API and you can get a good overview of it very quickly.
The mbed platform is a C++ API, so you will need to use C++ compilation.
There are several ways to achieve what you need, some examples:
Using the Ticker class:
#include "mbed.h"
Ticker TenSecondStuff ;
void TenSecondFunction()
{
f();
otherfunctions();
}
int main()
{
TenSecondStuff.attach( TenSecondFunction, 10.0f ) ;
// spin in a main loop.
for(;;)
{
continuousStuff() ;
}
}
Using wait_us() and the Timer class:
#include "mbed.h"
int main()
{
Timer t ;
for(;;)
{
t.start() ;
f() ;
otherfunctions() ;
t.stop() ;
wait_us( 10.0f - t.read_us() ) ;
}
}
Using the Ticker class, an alternative method:
#include "mbed.h"
Ticker ticksec ;
volatile static unsigned seconds_tick = 0 ;
void tick_sec()
{
seconds_tick++ ;
}
int main()
{
ticksec.attach( tick_sec, 1.0f ) ;
unsigned next_ten_sec = seconds_tick + 10 ;
for(;;)
{
if( (seconds_tick - next_ten_sec) >= 0 )
{
next_ten_sec += 10 ;
f() ;
otherfunctions() ;
}
continuousStuff() ;
}
}
Using mbed RTOS timer
#include "mbed.h"
#include "rtos.h"
void TenSecondFunction( void const* )
{
f();
otherfunctions();
}
int main()
{
RtosTimer every_ten_seconds( TenSecondFunction, osTimerPeriodic, 0);
for(;;)
{
continuousStuff() ;
}
}

Answer 2

If you want it simple try this
int delayTime = DELAY_10_SECS;
while(1==1)
{
delay(delayTime);
lastTime = getCurrTicks(); //Or start some timer with interrupt which tracks time
f(); // <-- function to be called every 10 seconds
otherfunctions();
delayTime = DELAY_10_SECS - ( getCurrTicks() - lastTime ); //Or stop timer and get the time
}

Answer 3

Asssuming you have some type of timer counter, perhaps one generated by a timer driven interrupt, try something like this:
volatile int *pticker; /* pointer to ticker */
tickpersecond = ... ; /* number of ticks per second */
/* ... */
tickcount = *pticker; /* get original reading of timer */
while(1){
tickcount += 10 * tickspersecond;
delaycount = tickcount-*pticker;
delay(delaycount); /* delay delaycount ticks */
/* ... */
}
This assumes that the ticker increments (instead of decrements), that the codde never get 10 seconds behind on a delay and assumes the number of ticks per second is an exact integer. Since an original reading is used as a basis, the loop will not "drift" over a long period of time.