with CONFIGURATION;           use CONFIGURATION;
with TEXT_IO;                 use TEXT_IO;
with COMMON_TO_BOTH_488;      use COMMON_TO_BOTH_488;
with PC_HW_488;               use PC_HW_488;
with UNCHECKED_CONVERSION;
with HW_SPECIFIC_EVENT_488;   use HW_SPECIFIC_EVENT_488;

package body HW_SPECIFIC_CONTROLLER_488 is

  package POINTER_IO is new INTEGER_IO(INTEGER);
  use POINTER_IO;

  LISTENER_LENGTH          : DATA_BYTE_COUNT_TYPE;
  LAST_WAIT_TIME           : DURATION := 3.0;

  TIMEOUT_VALUES           : array (TIMEOUT_TYPE) of DURATION
                           := (   0.0,
                                  0.000010,
                                  0.000030, 
                                  0.000100,
                                  0.000300,
                                  0.001000,
                                  0.003000,
                                  0.010000,
                                  0.030000,
                                  0.10000,
                                  0.30000,
                                  1.00000,
                                  3.00000,
                                 10.00000,
                                 30.00000,
                                100.00000,
                                300.00000,
                               1000.00000);

  function TO_DATA_BYTE is new UNCHECKED_CONVERSION(ID_TYPE, DATA_BYTE);

  procedure DUMP_ERROR is
  begin -- dump_error
   if PC_RETURN_STATUS.HW_STATUS < 0 then 
--   if PC_RETURN_STATUS.ERROR /= 0 then
--      for POINTER in STATUS_BIT loop
--         if PC_RETURN_STATUS.HW_STATUS(POINTER) then 
--            put(POINTER); put(" ");
--         end if;
--      end loop;
--      new_line;
        put("Status = "); put(PC_RETURN_STATUS.HW_STATUS); new_line;
        put("Error = "); put(PC_RETURN_STATUS.ERROR); new_line;
--        put("Error number = "); put(PC_RETURN_STATUS.ERROR); new_line;
--      if PC_RETURN_STATUS.HW_STATUS(ERR) then 
--         put_line(ERROR_MESSAGE(PC_RETURN_STATUS.ERROR));
--    end if;
      put("Count = "); put(PC_RETURN_STATUS.COUNT); new_line;
      new_line;
   end if;
end DUMP_ERROR;


function GET_TIMEOUT (TIMEOUT : in DURATION) return TIMEOUT_TYPE is 
   TOUT : TIMEOUT_TYPE := TIMEOUT_TYPE'last;
begin
   for TIM in TIMEOUT_VALUES'range loop
      if TIMEOUT <= TIMEOUT_VALUES(TIM) then
         TOUT := TIM;
         exit;
      end if;
   end loop;
   return TOUT;
end GET_TIMEOUT;

procedure HW_SERIAL_POLL (USERS_TO_POLL  : SP_SERVICE_ARRAY;
                          COUNT          : INTEGER_16;
                          RESULTS        : out SMALL_ARRAY;
                          RESULTS_COUNT  : out INTEGER_16) is

  LOOP_INDEX   : DATA_BYTE_COUNT_TYPE := 0;
  REAL_COUNT   : INTEGER_16;
  TEMP_ARRAY1  : BYTE_ARRAY(1..4);
  TEMP_ARRAY2  : BYTE_ARRAY(1..1);
  STATUS_BYTE  : BYTE_ARRAY(1..1);
  R_COUNT      : INTEGER_16 := 0;

begin

   loop

      TEMP_ARRAY1(1)   := 32+31; -- UNLISTEN
      TEMP_ARRAY1(2)   := 24;           --  Serial Poll Enable
      TEMP_ARRAY1(3)   := 32+TO_DATA_BYTE(DEVICE_ID); --  Controller to listen
      TEMP_ARRAY1(4)   := USERS_TO_POLL(LOOP_INDEX*2); -- user to poll
      LISTENER_LENGTH := 4;
      COMMAND(PC_RETURN_STATUS'address,
              TEMP_ARRAY1'address,
              LISTENER_LENGTH);
      DUMP_ERROR;

      RECEIVE_FROM_BUS(PC_RETURN_STATUS'address,
                       STATUS_BYTE'address,
                       1,
                       EOI_TERM);

      TEMP_ARRAY2(1)   := 25;           --  Serial Poll Disable
      LISTENER_LENGTH  := 1;
      COMMAND(PC_RETURN_STATUS'address,
              TEMP_ARRAY2'address,
              LISTENER_LENGTH);
      DUMP_ERROR;

      UNTALK_UNLISTEN;

      R_COUNT := R_COUNT + 1;

      RESULTS(LOOP_INDEX) := STATUS_BYTE(1);
      DUMP_ERROR;
      LOOP_INDEX := LOOP_INDEX+1;

   exit when LOOP_INDEX = DATA_BYTE_COUNT_TYPE(COUNT);

   end loop;

   RESULTS_COUNT := R_COUNT;

end HW_SERIAL_POLL;


procedure HW_SEND(QUEUE_NAME : in     MESSAGE_LINK;
                  STATUS     :    out STATUS_TYPE) is
  -- This routine will send the message that is at the front of the
  -- QUEUE_NAME
   THE_WAIT_TIME  : DURATION := QUEUE_NAME.NEXT.TIME_OUT;
begin
   if THE_WAIT_TIME /= LAST_WAIT_TIME then
      SET_TIMEOUT(PC_RETURN_STATUS'address,GET_TIMEOUT(THE_WAIT_TIME));
      LAST_WAIT_TIME := THE_WAIT_TIME;
   end if;
--put_line("It works with words in here");
--delay 0.01;
   SEND_IT(PC_RETURN_STATUS'address,
           QUEUE_NAME.NEXT.MESSAGE.MESSAGE'address,
           QUEUE_NAME.NEXT.MESSAGE.LENGTH);
--put_line("It works with words in here");
--delay 0.01;
   DUMP_ERROR;
--   if PC_RETURN_STATUS.HW_STATUS(ERR) then
   if PC_RETURN_STATUS.HW_STATUS < 0 then
      STATUS := INTEGER_16(PC_RETURN_STATUS.ERROR);
   else
      STATUS := 1;
   end if;
end HW_SEND;

procedure HW_SET_LISTENER(COMMANDS  : SMALL_MESSAGE) is
  TEMP_MESSAGE : BYTE_ARRAY(1..64);
begin  -- HW_SET_LISTENER
  TEMP_MESSAGE := COMMANDS.DATA;
  COMMAND(PC_RETURN_STATUS'address,
          TEMP_MESSAGE'address,
          COMMANDS.LENGTH);
  DUMP_ERROR;
end HW_SET_LISTENER;


procedure HW_SET_TALKER(COMMANDS  : SMALL_MESSAGE) is
  TEMP_MESSAGE : BYTE_ARRAY(1..64);
begin
  TEMP_MESSAGE := COMMANDS.DATA;
  COMMAND(PC_RETURN_STATUS'address,
          TEMP_MESSAGE'address,
          COMMANDS.LENGTH);
  DUMP_ERROR;
end HW_SET_TALKER;


procedure UNTALK_UNLISTEN is
  TEMP_ARRAY : BYTE_ARRAY(1..2);
begin
  TEMP_ARRAY(1) := 64+31; -- UNTALK
  TEMP_ARRAY(2) := 32+31; -- UNLISTEN
  LISTENER_LENGTH := 2;
  COMMAND(PC_RETURN_STATUS'address,
          TEMP_ARRAY'address,
          LISTENER_LENGTH);
  DUMP_ERROR;
--  I FIGURED OUT A BETTER WAY!!!!!!!!!!!!!!
--  delay 1.0;  -- until I figure out a better way of checking the state of
              -- the terminal.
end UNTALK_UNLISTEN;

procedure HW_CLEAR_ALL_DEVICES is
begin  -- HW_CLEAR_ALL_DEVICES
  SEND_INTERFACE_CLEAR(PC_RETURN_STATUS'address);
  DUMP_ERROR;
end HW_CLEAR_ALL_DEVICES;

procedure HW_RECEIVE_MESSAGE_EOI(COUNT     :    out INTEGER_16;
                                 STATUS    :    out STATUS_TYPE;
                                 WAIT_TIME : in     DURATION := 0.5) is
begin
   if WAIT_TIME /= LAST_WAIT_TIME then
      SET_TIMEOUT(PC_RETURN_STATUS'address,GET_TIMEOUT(WAIT_TIME));
      LAST_WAIT_TIME := WAIT_TIME;
   end if;
   RECEIVE_FROM_BUS(PC_RETURN_STATUS'address,
                    RECEIVED_MESSAGE_PTR.MESSAGE.MESSAGE'address,
                    DATA_BYTE_COUNT_TYPE'last,
                    EOI_TERM);  -- The largest message for UATL
   DUMP_ERROR;
   COUNT := PC_RETURN_STATUS.COUNT;
--   if PC_RETURN_STATUS.HW_STATUS(ERR) then
   if PC_RETURN_STATUS.HW_STATUS < 0 then
      STATUS := 0;
   else
      STATUS := 1;
   end if;
end HW_RECEIVE_MESSAGE_EOI;

procedure HW_RECEIVE_MESSAGE_LF(COUNT     :    out INTEGER_16;
                                STATUS    :    out STATUS_TYPE;
                                WAIT_TIME : in     DURATION := 0.5) is
begin
   if WAIT_TIME /= LAST_WAIT_TIME then
      SET_TIMEOUT(PC_RETURN_STATUS'address,GET_TIMEOUT(WAIT_TIME));
      LAST_WAIT_TIME := WAIT_TIME;
   end if;
   RECEIVE_FROM_BUS(PC_RETURN_STATUS'address,
                    RECEIVED_MESSAGE_PTR.MESSAGE.MESSAGE'address,
                    DATA_BYTE_COUNT_TYPE'last,
                    LF_TERM);  -- The largest message for UATL
   DUMP_ERROR;
   COUNT := PC_RETURN_STATUS.COUNT;
--   if PC_RETURN_STATUS.HW_STATUS(ERR) then
   if PC_RETURN_STATUS.HW_STATUS < 0 then
      STATUS := 0;
   else
      STATUS := 1;
   end if;
end HW_RECEIVE_MESSAGE_LF;

procedure HW_SHADOW_HANDSHAKE(STATUS     : out STATUS_TYPE;
                              DO_SHADOW  : in INTEGER_16) is 
begin
  GO_TO_STANDBY(PC_RETURN_STATUS'address,
                DO_SHADOW);
--  if PC_RETURN_STATUS.HW_STATUS(ERR) then
  if PC_RETURN_STATUS.HW_STATUS < 0 then
     STATUS := 0;
  else
     STATUS := 1;
  end if;
end HW_SHADOW_HANDSHAKE;

end HW_SPECIFIC_CONTROLLER_488;