0

我可以使用：

while(1==1) 
{

    delay(10);

    f();     // <-- function to be called every 10 seconds

    otherfunctions();

}

但这只需要 10 多秒，因为其他功能需要一些时间来执行。是否有考虑到其他函数所用时间的延迟函数，以便我可以f()每 10 秒准确调用一次？

我听说这可以通过一个可以在头文件中找到的聪明函数来完成，但我不记得是哪个。我认为它可能是#include mbed.h，但即使该函数包含在此头文件中，我也不知道它被称为什么或如何搜索它。

有人知道可以做我所追求的功能吗？

4

3 回答 3

4

您当然应该从阅读mbed 手册开始。它不是一个大型 API，您可以很快地对它有一个很好的了解。

mbed 平台是一个 C++ API，因此您需要使用 C++ 编译。

有几种方法可以实现您所需要的，一些示例：

使用Ticker类：

#include "mbed.h"

Ticker TenSecondStuff ;

void TenSecondFunction() 
{
    f();
    otherfunctions();
}

int main() 
{
    TenSecondStuff.attach( TenSecondFunction, 10.0f ) ;

    // spin in a main loop.
    for(;;) 
    {
        continuousStuff() ;
    }
}

使用wait_us()和Timer类：

#include "mbed.h"

int main()
{
    Timer t ;
    for(;;) 
    {
        t.start() ;
        f() ;
        otherfunctions() ;
        t.stop() ;

        wait_us( 10.0f - t.read_us() ) ;
    }
}

使用Ticker该类，另一种方法：

#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() ;
    }
}

使用 mbed RTOS 定时器

#include "mbed.h"
#include "rtos.h"

void TenSecondFunction( void const* )
{
    f();
    otherfunctions();
}

int main() 
{
    RtosTimer every_ten_seconds( TenSecondFunction, osTimerPeriodic, 0);

    for(;;)
    {
        continuousStuff() ;
    }
}
于 2015-03-13T20:22:49.220 回答
1

如果你想要它简单试试这个

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
}
于 2015-04-02T12:12:58.463 回答
0

假设您有某种类型的计时器计数器，可能是由计时器驱动的中断生成的，请尝试以下操作：

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 */
        /* ... */
    }

这假设代码递增（而不是递减），代码永远不会延迟 10 秒，并假设每秒的滴答数是一个精确的整数。由于使用原始读数作为基础，因此循环不会在很长一段时间内“漂移”。

于 2015-03-13T20:08:36.727 回答