JAVA-BASED REAL-TIME PROGRAMMING

3. Multi-Threaded Programming
user interface using the javax.swing classes and only some threading for handling
the network will probably inherit graphical properties and implement
Runnable when needed. For an embedded control application, on the other
hand, threading (and timing) is a primary issue and inheritance from class
Thread is a natural choice.
Some programmers prefer to always use the Runnable alternative as their
standard way of doing things, whereas others always create Thread subclasses
(sometimes having an internal thread object when there is a need to inherit
from other classes). In the sequel, threading is the primary issue so we will
mostly use Thread as a base class, but utilizing interface Runnable is covered
as well.
3.1.2 Time
Even though concurrent programs do not ensure timing, it is very useful
to let actions depend on real time, i.e., reading the real-time clock which
is available on any useful computing platform. In Java the default time
unit is milliseconds, and the current clock time is obtained by calling System.currentTimeMillis
which returns the time in milliseconds counted from
beginning of 1970. Since the return value is of type long, the y2k type of
problem that comes with the finite time range is quite far in the future (year
292272993, which should mean no problem for most applications).
The advantage with currentTimeMillis stored in a built in numeric datatype
(long) is that it can be conveniently used for computations. For humanreadable
time Java also provides a Date class which also copes with time
zones, locales, and the like. That is, however, a matter of formatting and for
our needs it is the system time in milliseconds that is relevant.
Assume we want to compute the trend (or numerical derivative) of an
analog input signal. Further assume we have a method inValue that handles
the AD conversion and returns a scaled value as a float, and let us say that we
have an infinite resolution in value. Concerning resolution in time, we have the
millisecond time described above. That time is updated via a clock interrupt
routine in the JVM or OS. Some embedded computers are equipped with a
high resolution real-time clock, but using it would require a native method
and loss of portability. Using only the standard 1 ms resolution, an attempt
to compute the trend could be:
1 float trend() {
2 float x, x0 = inValue(); // [V]
3 long t, t0 = System.currentTimeMillis ();
4 while ((t=System.currentTimeMillis ())==t0) {/*Busy waiting.*/};
5 x = inValue();
6 return (x-x0)/(t-t0)*1000; // [V/s]
7 }
With an input signal that increases constantly with 1 V/s we would like to
obtain the value 1.0, but already with such a small piece of software it is hard
44 2012-08-29 16:05