Use an interrupt handler for your operating system
to pass data to the CPU.
Typically, a static function
without parameters is added by passing its address to an operating
system operation like InstallIntHdlr (operating system-dependent).
The static function can be either a special singleton object or a
function defined within a package. This operation must use compiler-specific
utilities to get to the registers. Eventually, it must return and
execute a return from the interrupt instruction.
About this task
You can pass the data from the interrupt
handler to the CPU (assuming that the interrupt handler needs to),
in the following ways:
- Generate an event (using the GEN() macro),
which then goes through the operating system to the reactive object
(which is in a different thread).
- Use a rendezvous object with a read/write toggle
lock. The interrupt handler checks whether the lock is in the write
state, then updates the data and puts the lock in the read state.
The reader (in another thread) periodically checks the lock and only
reads when it is in the read state. If it is in that state, the reader
reads the data and updates the lock to its write state. This update
can easily be extended to a queue structure.
- Write the interrupt handler manually outside IBM® Rational® Rhapsody® and
send it to the operating system message queue for the target thread.
Typically, if the operating system does not support interrupt handlers
directly, you store the current handler in your function and write
the address of the function in the appropriate place in the interrupt
vector table. When the interrupt goes off, either the new function
replaces the old interrupt handler (meaning when it is done it simply
returns) or it chains to it (calls the original). In any event, when
the interrupt handler is decommissioned, you replace the vector in
the vector table with the original address.