Re: Using "delay until" in real-time

[tmoran@acm.org]

>It's more likely to be fixed-point.  If you're using
>Gnat, Ada.Real_Time.Time and Ada.Real_Time.Time_Span are both derived
>from Duration, which is a 64-bit fixed-point type with a Small of
>exactly 1.0e-9 (one nanosecond).
  (A win for mathematical oversimplification over engineering, ;)

Clearly you need to do your arithmetic in a system that correctly
represents a single tick.  Integers come to mind.  How about

  Iteration_Count : Natural := 0;
  ...
  delay until Start_Time + Ada.Real_Time.Time_Span(Iteration_Count)/60;

If Ada.Real_Time.Time_Span(Iteration_Count) is going to get too large
before your program is done, then you need something that isn't so big
it overflows, but will count ticks without roundoff.  A fixed point
value with suitable range and a 'small of 1/60 will do that.  Then
you need a way to convert this accurate time to an Ada.Real_Time.Time
How about:

with Ada.Real_Time;
package Accurate_Time is

  type Time_Span is delta 1.0/60 range 0.0 .. long enough
  for Time_Span'small use 1.0/60;

  type Time is private;

  function Clock return Time;

  function "+"(Left : Time; Right : Time_Span) return Time;

  function To_Real_Time(T : in Time) return Ada.Real_Time.Time;

private

  type Time is record
    Start_SC : Ada.Real_Time.Seconds_Count;
    Start_TS : Ada.Real_Time.Time_Span;
    Since : Time_Span;
  end record;

end Accurate_Time;

package body Accurate_Time is
  use Ada.Real_Time;

  function Clock return Time is
    Result : Time;
    Now : Ada.Real_Time.Time := Ada.Real_Time.Clock;
  begin
    Ada.Real_Time.Split(Now, Result.Start_SC, Result.Start_TS);
    Result.Since := 0.0;
    return Result;
  end Clock;

  function "+"(Left : Time; Right : Time_Span) return Time is
    Result : Time := Left;
  begin
    Result.Since := Result.Since + Right;
    return Result;
  end "+";

  function To_Real_Time(T : in Time) return Ada.Real_Time.Time is
    Whole_Seconds_Since : Ada.Real_Time.Seconds_Count;
    Fractional_Seconds_Since : Time_Span;
    SC : Ada.Real_Time.Seconds_Count;
    TS : Ada.Real_Time.Time_Span;
  begin
    Whole_Seconds_Since := Ada.Real_Time.Seconds_Count(T.Since);
    if Time_Span(Whole_Seconds_Since) > T.Since then
      Whole_Seconds_Since := Whole_Seconds_Since-1;
    end if;
    Fractional_Seconds_Since := T.Since - Time_Span(Whole_Seconds_Since);
    SC := T.Start_SC + Whole_Seconds_Since;
    TS := T.Start_TS
          + Ada.Real_Time.To_Time_Span(Duration(Fractional_Seconds_Since));
    return Ada.Real_Time.Time_Of(SC, TS);
  end To_Real_Time;

end Accurate_Time;

>However, its quite possible that the real-time clock hardware on my
>platform (PC) uses something like nannoseconds, and the OS call just
>approximates that.
  If it uses the usual 8253 descendant, that clock hardware ticks
at 1,193,182 Hz, (1/3 of the NTSC TV color subcarrier crystal
frequency) which is 0.838 mics/tick.