---------------------------------------------------------------------------
--
-- Package:     INTERFACE_488
--
-- Function:     Provides an Ada interface to 488.
--
--     The package is contains a single entry for outbound messages, and
--      a single entry point for inbound messages.
--
-- Version:     1
--
-- Date:     25 September 1987
--
---------------------------------------------------------------------------
with SYSTEM;                      use SYSTEM;
with CONTROLLER_488;              use CONTROLLER_488;
with TERMINAL_488;                use TERMINAL_488;
with COMMON_TO_BOTH_488;          use COMMON_TO_BOTH_488;
with DATA_RECORDING;              use DATA_RECORDING;
with UATL_DISPLAY;                use UATL_DISPLAY;
with CONVERSIONS;                 use CONVERSIONS;
with UATL_OPCOM;                  use UATL_OPCOM;

pragma ELABORATE (CONTROLLER_488,
                  TERMINAL_488);

package body INTERFACE_488 is

   INTERFACE_WAS_INITIALIZED : BOOLEAN := FALSE;

   NO_RECEIVERS : constant INTERFACE_USERS := (others => FALSE);

   function CONVERT is new CONVERT_TO_BYTE_ARRAY (GENERAL_488_MESSAGE);


   procedure INITIALIZE_488_INTERFACE (DEVICE_ID : in ID_TYPE;
                                       CONTROL   : in BOOLEAN;
                                       PORT      : in INTEGER := 0) is
   begin
      if not INTERFACE_WAS_INITIALIZED then  
         INTERFACE_WAS_INITIALIZED      := TRUE;
         COMMON_TO_BOTH_488.CONTROL     := CONTROL;
         COMMON_TO_BOTH_488.DEVICE_ID   := DEVICE_ID;
         COMMON_TO_BOTH_488.PORT_NUMBER := PORT;
         if CONTROL then
            CONTROLLER_488.CONTROLLER_488_TASK.START;
         else
            TERMINAL_488.TERMINAL_488_TASK.START;
         end if;
      else
         UATL_OPERATOR_ALERT
           ("INITIALIZE_488_INTERFACE error: Attempt made to re-initialize.");
      end if;
   end INITIALIZE_488_INTERFACE;

   procedure RECEIVE(BUFFER        :     out GENERAL_488_MESSAGE;
                     MSG_RECEIVED  :     out BOOLEAN;
                     CALL_TYPE     :  in     RECEIVE_CALLS := WAIT;
                     DELAY_TIME    :  in     DURATION      := 0.0) is
   begin
      case CALL_TYPE is
         when WAIT    =>  
            IO_488.RECEIVE(BUFFER);
            MSG_RECEIVED := true;
         when NO_WAIT =>  
            select
               IO_488.RECEIVE(BUFFER);
               MSG_RECEIVED := true;
            else
               MSG_RECEIVED := false;
            end select;
         when TIMED   =>  
            select
               IO_488.RECEIVE(BUFFER);
               MSG_RECEIVED := true;
            else
               delay DELAY_TIME;
               MSG_RECEIVED := false;
            end select;
      end case;
   end RECEIVE;


   procedure SEND(BUFFER     : in GENERAL_488_MESSAGE;
                  WAIT_TIME  : in DURATION := 0.5) is
      MSG_PTR     : MESSAGE_POINTER;
      POLL_PTR    : MESSAGE_POINTER;
      IN_MESSAGE  : GENERAL_488_MESSAGE := BUFFER;
      NORMAL_SEND : BOOLEAN             := FALSE;
   begin
      if INTERFACE_WAS_INITIALIZED then 
         if MESSAGE_WILL_BE_RECORDED(IEEE488,TO_488_BUS) then
            RECORD_MESSAGE (MSG             => CONVERT(IN_MESSAGE),
                            INTERFACE_ID    => IEEE488,
                            BATCH_ID        => TO_488_BUS);
         end if;  
         if MESSAGE_WILL_BE_DISPLAYED(IEEE488,TO_488_BUS) then
            ONLINE_DISPLAY (MSG    => CONVERT(IN_MESSAGE),
                            BAT    => TO_488_BUS,
                            INT    => IEEE488);
         end if;  
         if COMMON_TO_BOTH_488.CONTROL and then
               ACTIVE_DEVICES /= null then
            for USER in ACTIVE_DEVICES'range loop
               if IN_MESSAGE.RECEIVE(ACTIVE_DEVICES(USER).ADDRESS) and then
                     ACTIVE_DEVICES(USER).PROTOCOL = UATL then
                  IN_MESSAGE.RECEIVE(ACTIVE_DEVICES(USER).ADDRESS) := FALSE;
                  POLL_PTR := new MESSAGE_LINK'
                     (null, WAIT_TIME, I488_IO_TRIES, IN_MESSAGE);
                  QUEUE_TASK.QUEUE
                     (POLL_QUEUE(ACTIVE_DEVICES(USER).ADDRESS).all, POLL_PTR);
               end if;
            end loop;
            if IN_MESSAGE.RECEIVE /= NO_RECEIVERS then
               NORMAL_SEND := TRUE;
            end if;
         else
            NORMAL_SEND := TRUE;
         end if;
         if NORMAL_SEND then
            MSG_PTR := new MESSAGE_LINK'
                             (null, WAIT_TIME, I488_IO_TRIES, IN_MESSAGE);
            QUEUE_TASK.QUEUE(SEND_QUEUE, MSG_PTR);
            if COMMON_TO_BOTH_488.CONTROL then
               select
                  CONTROLLER_488_TASK.BUS_TRANSMIT;
               else
                  null;
               end select;
            end if;
         end if;
      else
         UATL_OPERATOR_ALERT
       ("SEND error: Attempt to transmit on uninitialized IEEE-488 interface.");
         delay 3.0;
      end if;
   end SEND;

   procedure SETUP_IEEE488_DEVICES (I488_DEVICES : in DEVICE_LIST) is
   begin
      if COMMON_TO_BOTH_488.CONTROL then
         CONTROLLER_488_TASK.SETUP_IEEE488_DEVICES (I488_DEVICES);
      else
         UATL_OPERATOR_ALERT
         ("SETUP_THE_SERIAL_POLL error: This IEEE-488 unit is not controller.");
      end if;
   end SETUP_IEEE488_DEVICES;

   procedure TERMINAL_POLLING_RATE(POLL_TIME : in DURATION) is
   begin
      if not(COMMON_TO_BOTH_488.CONTROL) then
         TERMINAL_488_TASK.TERMINAL_POLLING_RATE(POLL_TIME);
      else
         UATL_OPERATOR_ALERT
        ("TERMINAL_POLLING_RATE error: This IEEE-488 unit is not a terminal.");
      end if;
   end TERMINAL_POLLING_RATE;

end INTERFACE_488;