JAVA-BASED REAL-TIME PROGRAMMING

2.2. Our physical world is parallel
For a single (scalar) differential equation, we then have an even harder
type of equality. Apart from the previously mentioned problem, we have to
compute derivatives of variables (representing physical states) and then we also
get truncation and quantification effects due to the binary representation of
data with finite wordlength. Therefore, we can only work with approximations
of the real world object, even if its properties would be known exactly.
For a set of coupled differential equations, modelling our real-world objects,
the sequencing effect is an even bigger problem since all equations are to hold
in parallel. Additionally, state changes may occur at discrete times which
cannot be exactly represented, and our models may include logical relations.
To overcome these problems, the following techniques are used within systems
engineering:
1. For less complex dynamics, equations may be solved and only the explicit
solution need to be implemented. For instance, a real-time computer
game for playing “pinball” includes simulation of the ball dynamics,
which can be expressed as a simple type of numeric integration.
2. For systems with low demands on accuracy or performance, we may approximate
or even omit the model equations. For instance, for soft-stop
control of elevator motions we may use manually-tuned open-loop control
without any internal model. This is opposed to optimal performance
robot motions which require extensive evaluation of motion dynamics.
3. We may use special purpose languages and execution systems that transforms
declarative descriptions to computable expressions, i.e., a combination
of software technology and numerical analysis. For instance, it is
well known within the software oriented part of the control community
that object oriented models of dynamic properties requires declarative
languages such as Modelica. Another example is that certain types of
logical relations may be conveniently expressed in Prolog.
The computational difficulties are taken care of at ‘system design time’, which
means that we use high performance workstations to analyze, simulate, and
to determine a control algorithm that is simple to compute in the embedded
system. For instance, based on the equations and a dynamic model of
a system (like dynamic properties of a vehicle) we may use simulation tools
to compute the behaviour (like rotation, position and velocity) when certain
actions are applied (like speed and steering wheel commands), and some control
design tool help us determine a control law expression which can easily
be implemented and computed in the embedded software.
The conclusion from this section is that our real physical world can be
quite troublesome from a programming point of view. Therefore, we should
not apply object orientation and imperative languages (such as Java) outside
their conceptual limits, and we should design our systems so that algorithmic
19