Fully-portable time delay of specified length

[Martin Wells]

I'm doing an embedded systems project and I'm programming it as fully-
portable C89 (except of course for setting the pin values).

I need to put delays in the program, in the vicinity of 250 ms. (They
don't need to be exact).

Does C have a built-in method of putting in delays?

If not, I was thinking of defining a macro called "FLOPS" (i.e.
floating-point operations per second) and then doing something like:

void Delay(unsigned const fraction_of_full_second)
{
long unsigned amount_flop = FLOPS / fraction_of_full_second;

float x = 56.3;

do x /= x;
while (--amount_flop);
}

(Obviously I'll have to take into account the extra delay of looping
but you get the general idea)

Martin

[keith]

On 8 Oct, 12:43, Martin Wells <[e-mail]:

I'm doing an embedded systems project and I'm programming it as fully-
portable C89 (except of course for setting the pin values).

I need to put delays in the program, in the vicinity of 250 ms. (They
don't need to be exact).

Does C have a built-in method of putting in delays?

Assuming you have a reasonably standard set of libraries, take a look
at nanosleep(3RT). You'll need to link librt. An older alternative
is usleep(3C).

[Mark Bluemel]

ke***@bytebrothers.co.uk wrote:

On 8 Oct, 12:43, Martin Wells <[e-mail]:

>I'm doing an embedded systems project and I'm programming it as fully-
portable C89 (except of course for setting the pin values).

I need to put delays in the program, in the vicinity of 250 ms. (They
don't need to be exact).

Does C have a built-in method of putting in delays?

Assuming you have a reasonably standard set of libraries,

I think you missed out the word "POSIX" or similar in this sentence...

... take a look
at nanosleep(3RT). You'll need to link librt. An older alternative
is usleep(3C).

[Chris Hills]

In article <11**********************@y42g2000hsy.googlegroups .com>,
Martin Wells <wa****@eircom.netwrites

>
I'm doing an embedded systems project and I'm programming it as fully-
portable C89 (except of course for setting the pin values).

I need to put delays in the program, in the vicinity of 250 ms. (They
don't need to be exact).

Does C have a built-in method of putting in delays?

No. You are best off using a Hw timer.
Write a function called delay which takes a parameter in ms.
You can then do your own library module which will contain the not
standard code.

Try comp.arch.embedded and say what your MCU is

>If not, I was thinking of defining a macro called "FLOPS" (i.e.
floating-point operations per second) and then doing something like:

void Delay(unsigned const fraction_of_full_second)
{
long unsigned amount_flop = FLOPS / fraction_of_full_second;

float x = 56.3;

do x /= x;
while (--amount_flop);
}

(Obviously I'll have to take into account the extra delay of looping
but you get the general idea)

This will be fraught with problems as the compiler may or may not
optimise it differently as you build the application.

--
\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
\/\/\/\/\ Chris Hills Staffs England /\/\/\/\/
/\/\/ ch***@phaedsys.org www.phaedsys.org \/\/\
\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/

[Joachim Schmitz]

<ke***@bytebrothers.co.ukschrieb im Newsbeitrag
news:11**********************@k79g2000hse.googlegr oups.com...

On 8 Oct, 12:43, Martin Wells <[e-mail]:

>I'm doing an embedded systems project and I'm programming it as fully-
portable C89 (except of course for setting the pin values).

I need to put delays in the program, in the vicinity of 250 ms. (They
don't need to be exact).

Does C have a built-in method of putting in delays?

Assuming you have a reasonably standard set of libraries, take a look
at nanosleep(3RT). You'll need to link librt. An older alternative
is usleep(3C).

Neither is part of C89.

Bye, Jojo

[Army1987]

On Mon, 08 Oct 2007 04:43:46 -0700, Martin Wells wrote:

>
I'm doing an embedded systems project and I'm programming it as fully-
portable C89 (except of course for setting the pin values).

I need to put delays in the program, in the vicinity of 250 ms. (They
don't need to be exact).

Does C have a built-in method of putting in delays?

No, but you could use a loop and clock() if you have it:
clock_t start = clock();
while(clock() - start < 0.250 * CLOCKS_PER_SEC)
continue;

If not, I was thinking of defining a macro called "FLOPS" (i.e.
floating-point operations per second) and then doing something like:

void Delay(unsigned const fraction_of_full_second)
{
long unsigned amount_flop = FLOPS / fraction_of_full_second;

float x = 56.3;

Make it volatile or a sufficiently good compiler will remove the
next assignment.

do x /= x;
while (--amount_flop);
}

(Obviously I'll have to take into account the extra delay of looping
but you get the general idea)

--
Army1987 (Replace "NOSPAM" with "email")
A hamburger is better than nothing.
Nothing is better than eternal happiness.
Therefore, a hamburger is better than eternal happiness.

[Keith Thompson]

Army1987 <ar******@NOSPAM.itwrites:

On Mon, 08 Oct 2007 04:43:46 -0700, Martin Wells wrote:

>I'm doing an embedded systems project and I'm programming it as fully-
portable C89 (except of course for setting the pin values).

I need to put delays in the program, in the vicinity of 250 ms. (They
don't need to be exact).

Does C have a built-in method of putting in delays?

No, but you could use a loop and clock() if you have it:
clock_t start = clock();
while(clock() - start < 0.250 * CLOCKS_PER_SEC)
continue;

You need to be aware that the value returned by clock() is specified
to be an indication of CPU time, not of wall clock time. They may
well be the same in your embedded environment, but you should confirm
that before depending on it.

On the other hand, a freestanding implementation isn't required to
provide the clock() function.

The best way to do this is likely to depend heavily on the nature of
your target environment. It might provide some function that does
exactly what you want. I can imagine that using a busy loop rather
than invoking some kind of sleep or delay function might cause
problems (on a multi-processing system, it needlessly gobbles CPU
time; on a single-process embedded system, it might needlessly gobble
power).

Somebody suggested posting to comp.arch.embedded; that's probably your
best bet.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Thad Smith]

Chris Hills wrote:

In article <11**********************@y42g2000hsy.googlegroups .com>,
Martin Wells <wa****@eircom.netwrites

>>
I'm doing an embedded systems project and I'm programming it as fully-
portable C89 (except of course for setting the pin values).

I need to put delays in the program, in the vicinity of 250 ms. (They
don't need to be exact).

Does C have a built-in method of putting in delays?

No. You are best off using a Hw timer.
Write a function called delay which takes a parameter in ms.
You can then do your own library module which will contain the not
standard code.

Try comp.arch.embedded and say what your MCU is

I agree. I also use C89 as much as practical on embedded targets, but
timer functions is one that often makes sense to use target-specific
code, especially on smaller processors. Your library may already
contain suitable time-related functions for your target.

--
Thad

[karthikbalaguru]

On Oct 8, 4:43 pm, Martin Wells <[e-mail]:

I'm doing an embedded systems project and I'm programming it as fully-
portable C89 (except of course for setting the pin values).

I need to put delays in the program, in the vicinity of 250 ms. (They
don't need to be exact).

Does C have a built-in method of putting in delays?

If not, I was thinking of defining a macro called "FLOPS" (i.e.
floating-point operations per second) and then doing something like:

void Delay(unsigned const fraction_of_full_second)
{
long unsigned amount_flop = FLOPS / fraction_of_full_second;

float x = 56.3;

do x /= x;
while (--amount_flop);

}

(Obviously I'll have to take into account the extra delay of looping
but you get the general idea)

nanosleep is a good bet.
But, it further depends on the type of MPU you use and the compiler
supported sleep routines
for giving you the desired delays. Check your specification/datasheet
also.

Karthik Balaguru

[karthikbalaguru]

On Oct 8, 4:43 pm, Martin Wells <[e-mail]:

I'm doing an embedded systems project and I'm programming it as fully-
portable C89 (except of course for setting the pin values).

I need to put delays in the program, in the vicinity of 250 ms. (They
don't need to be exact).

Further, How do you expect the delay to be portable ?
It has dependencies on the architecture (Processor Clk) and so it will
be varying from
architecture to architecture.
Maybe, you need to know list of all the Processor clocks and program
it accordingly.
But, thats not an easy job .

Karthik Balaguru