Re: Advice, tasking and hardware

[rieachus@comcast.net]

I think there is a lot of well argued stuff here which is several months ahead of where the OP is.

If you are writing a controller for a wall of instruments talking IEEE 488 or some such, and the goal is to write programs for automated testing, the first huge win with Ada is:

   In Ada you model the environment, not the problem set.

It is not unusual to have changes in the requirements for automated testing (or just about any other field) at the last minute.  If you modeled the environment/solution space, a small (in text terms) change in the requirements with require only a small change in the code.

Next, there are choices you have to make in doing your modelling.  Having a package corresponding to each instrument, and putting a task inside iff you need to deal with state in the instrument.  Otherwise use a protected object to insure sequential communications.

Some instruments have state, lots of state, others are nice and use a stateless protocol.  To use POs, to control other hardware you definitely want to do a classic semaphore.  Any thread/task talking to that device does a Seize, and a Release when done.  For devices with state, you need a task that tracks the state of the device.  Would it were so simple as that makes it sound.  The interface the package presents to the rest of the world is clean, but your task may end up pages long to deal with error states and recovery.

Finally how you deal with task termination will depend to a great deal on the safety requirements.  There is a design pattern when you need each active device to have a call during shutdown and multiple shutdowns are the way to go.  Basically you have a shutdown package in the with list of packages with hidden tasks.  You create a new task which does what is necessary and it waits on a task entry provided by the shutdown package:

package Shutdown is
  task Suspend is
    entry Stop;
    entry Wait;
  end Suspend;
end Shutdown;
...
package body Shutdown is
begin
 task body Suspend is
 begin
   accept Stop;
   loop
     select
       accept Wait;
     or
       accept Stop; -- in case of multiple calls to Stop.
     or
       terminate;
     end select;
   end loop;
 end Shutdown;

  Now any package can call Shutdown.Suspend.Wait from a task that does the necessary shutdown actions.  (This is about the only situation where you want to call abort in Ada.  You have a task which deals with normal operations, and a emergency task which turns of the gas, high voltage, fuel, or whatever.)

   task Killer is
   end Killer  -- no entries.

   task body Killer is 
   begin
     Shutdown.Suspend.Wait;
     select
       Local_Task.Shutdown;
     or delay XXX;  --- delay time will depend on physical system properties.
     end select;
     delay YYY;   --- delay time will depend on physical system properties.
     abort Local_Task;
     -- shut down everything controlled by Local_Task here.
   end Killer;