ASMB,R,L,C     ** RT TIME MODULE ** 
      HED REAL TIME TIME MODULE 
*     NAME:   RTIME 
*     SOURCE: 92060-18014 
*     RELOC:  92060-16014 
*     PGMR:   G.A.A.
* 
*  ***************************************************************
*  * (C) COPYRIGHT HEWLETT-PACKARD COMPANY 1975.  ALL RIGHTS     *
*  * RESERVED.  NO PART OF THIS PROGRAM MAY BE PHOTOCOPIED,      *
*  * REPRODUCED OR TRANSLATED TO ANOTHER PROGRAM LANGUAGE WITHOUT*
*  * THE PRIOR WRITTEN CONSENT OF HEWLETT-PACKARD COMPANY.       *
*  ***************************************************************
* 
      NAM RTIME,0 92060-16014 REV.1710 770131 
* 
      SUP 
********************************************************************
* 
* 
***** AMD ***** JUL,73
* 
* 
********************************************************************
* 
*   RTIME ENTRY POINT NAMES 
* 
      ENT $TADD,$CLCK,$TREM,$TIME,$TIMV 
      ENT $ETTM,$TIMR,$ONTM,$TMRQ,$SCLK 
      ENT $BATM 
* 
*   RTIME EXTERNAL REFERENCE NAMES
* 
      EXT $INER,$DEVT,$LIST,$XEQ
      EXT $ERMG,$MESS,$SYMG,$IDSM 
      EXT $WORK 
* 
********************************************************************
* 
*     THE RTIME MODULE OF HP2100 REAL TIME EXECUTIVE CONSISTS OF   *
* 
*        1.  TIME PROCESSOR ROUTINES                               *
*        2.  CLOCK START UP ROUTINE.                               *
* 
********************************************************************
      HED REAL TIME CLOCK-TIME LIST PROCESSING
********************************************************************
*        THE REAL TIME CLOCK PROCESSOR SECTION OF HP-2100 REAL TIME*
*     EXECUTIVE HANDLES ALL TIME DEPENDENT FUNCTIONS:              *
*        1. INCREMENT REAL TIME CLOCK VALUES EVERY 10 MILLISECOND. *
*        2. SCHEDULE PROGRAMS AT THE REQUESTED TIME AND COMPUTE ITS*
*              NEXT START TIME.                                    *
*        3. ADD PROGRAMS TO THE TIME LIST.                         *
*        4. REMOVE PROGRAMS FROM THE TIME LIST.                    *
*        5. OUTPUT CURRENT SYSTEM TIME TO USER ARRAY.              *
*        6. SET ID SEGMENT VALUES AS REQUESTED BY USER.            *
********************************************************************
      SPC 1 
*        THE $CLCK ROUTINE FUNCTIONS AS FOLLOWS:                   *
*              THE ROUTINE IS ENTERED EVERY 10 MILLISECOND DUE     *
*                  TO TIME BASE GENERATOR INTERRUPTS.              *
*              THE TIME VALUE IS INCREMENTED BY 10 MILLISECONDS.   *
*              THE TIME VALUES OF EACH PROGRAM IN TIME LIST IS     *
*                   COMPARED TO THE CURRENT TIME. IF THE TIMES     *
*                   COMPARE AND THE PROGRAM IS DORMANT, A SCHEDULE *
*                   REQUEST IS MADE VIA LIST PROCESSOR. REGARDLESS *
*                   OF PROGRAM STATUS, THE NEXT START TIME IS      *
*                   COMPUTED UNLESS THE MULTIPLE VALUE IS ZERO-    *
*                   WHICH MEANS THAT THE PROGRAM IS TO BE REMOVED  *
*                   FROM TIME LIST.                                *
*              THE TIME-OUT CLOCKS FOR ALL ACTIVE DEVICES ARE 
*                   UPDATED.  IF ANY DEVICE HAS TIMED-OUT,
*                   RTIOC IS ENTERED TO PROCESS THE CONDITION.
*                                                                  *
$CLCK ISZ $TIME     STEP THE LOW ORDER TIME VALUE 
      JMP CL010     GO TO PROCESS LISTS 
      ISZ $TIME+1   STEP THE HIGH ORDER TIME VALUE
      JMP CL010     GO TO PROCESS LISTS 
      LDA RS1       RESET THE COUNTER 
      LDB RS2       TO THE FULL 
      STA $TIME     DAYS WORTH OF 
      STB $TIME+1   OF TENS OF MS.
      ISZ $TIME+2   STEP THE DAYS/YEARS COUNTER 
* 
*     CHECK IF TIME TO SCHEDULE PROGRAM 
* 
CL010 LDB TLIST    TIME LIST
CL011 CLE,SZB,RSS   IF THRU PROCESSING IT, GO 
      JMP TOBAT      PROCESS BATCH TIME-OUT 
      STB POINT     SAVE TIME LINK
      ADB D2        B NOW PTS TO IDSEG TIME VAULE 
      DLD B,I       GET THE SCHEDULE TIME 
      CPA $TIME     IF BOTH WORDS MATCH 
      CCE           THEN
      CPB $TIME+1   THE 
      SEZ,RSS       TIME IS 
      JMP CH010 
      JSB TMSCH     NOW SO SCHEDULE THE PROG. 
* 
*     INCREMENT TO NEXT PROGRAM IN LIST 
* 
CH010 LDB POINT,I  GET ADDR OF NEXT PROG IN LIST
      JMP CL011    GO TO COMPARE NEXT PROG IN LIST
* 
*     IF CURRENT PGM IS BATCH THEN STEP THE TIMER 
* 
TOBAT LDB XEQT      GET THE BATCH BIT 
      SZB           IF NO CURRENT PGM SKIP
      CPB DD.RT     IF CURRENT PGM IS D.RTR DO NO TIME
      JMP IOTOP     BUT GO DO DEVICE TIME OUTS
* 
      CPB $IDSM     IF SMP
      JMP IOTOP 
      ADB D20       TO
      LDA B,I       GET THE BATCH FLAG
      SSA,RSS       IF NOT BATCH
      JMP IOTOP     SKIP TEST 
* 
      ISZ $BATM     STEP BATCH TIMER
      JMP IOTOP     IF NO ROLL OVER EXIT
* 
      ISZ $BATM+1   ELSE STEP NEXT WORD 
      JMP IOTOP     IF NO ROLL OVER SKIP
* 
      RAL           PUT FATHER BIT IN 15. 
      SSA           IF THIS IS A SON
      JMP ABOR      THEN ABORT HIM
* 
      RAR           RESTORE A 
      IOR B10K      SET THE BREAK FLAG
      STA B,I       AND RESET THE WORD
      JMP IOTOP     CONTINUE WITH TIME OUTS 
* 
ABOR  LDA ATI       GET THE TI ABORT MESSAGE
      LDB BLANK 
      JSB $ERMG     GO ABORT HIM
* 
*   PROCESS DEVICE TIME-OUT CLOCKS
* 
IOTOP LDA EQT#      SET NEGATIVE OF 
      CMA,INA        NUMBER OF EQT
      STA $TIMV      ENTRIES FOR INDEX
      LDA EQTA      POINT TO WORD 15
IOTO2 ADA D14        OF FIRST EQT ENTRY 
      LDB A,I       LOAD WORKING CLOCK- 
      SZB           IS IT ACTIVE? 
      ISZ A,I        YES: INCREMENT IT
      INA,RSS       IT HAS NOT TIMED-OUT
      JMP $DEVT     GO TO TIME-OUT PROCESSOR
      ISZ $TIMV     THRU? 
      JMP IOTO2      NO: GO DO NEXT ONE 
      JMP $XEQ       YES; NO TIME-OUTS-RETURN 
      SPC 1 
D20   DEC 20
M7777 OCT 7777
RS1   OCT 25000 
RS2   OCT 177574
PRS1  OCT 153000
PRS2  OCT 203 
BLANK ASC 1,
      HED REAL TIME CLOCK SCHEDULE ON TIME ROUTINE
* 
*     PROGRAM TO BE SCHEDULED 
* 
*     THE TMSCH ROUTINE SCHEDULES THE PROGRAM IF DORMANT
*     THEN COMPUTES ITS NEXT SCHEDULE TIME FROM ITS 
*     RES CODE AND MULT FACTOR IN ITS ID-SEGMENT. 
*     IF THE RES CODE IS ZERO THE PROGRAM IS REMOVED FROM 
*     THE TIME LIST.
* 
*     THE CALLING SEQUENCE IS:
*     SET POINT TO THE ADDRESS OF THE TIME LINK WORD
*     JSB TMSCH 
* 
TMSCH NOP 
      CCB           COMPUTE THE STATUS ADDRESS
      ADB POINT 
      LDA B,I       GET THE STATUS
      AND D15       GET THE LOW BITS
      SZA           IF NOT DORMANT
      JMP CH026     FORGIT IT 
      ADB DM15      ELSE SET B TO THE ID-SEG ADDRESS
      JSB $LIST    CALL LIST PROCESSOR TO SCHED PROG
      OCT 401       THE PROGRAM 
* 
*     CHECK IF NEXT SCHEDULE TIME TO BE COMPUTED
* 
CH026 LDB POINT 
      INB 
      LDA B,I       RES CODE/MULT FACTOR
      AND M7777 
      SZA,RSS       IF ZERO, THEN NO NEW START TIME 
      JMP CH040     GO REMOVE PROG FROM LIST
      STA TEMP      SAVE MULTIPLICATION FACTOR
      JSB TUDAT     GO UPDATE THE SCHEDULE TIME 
      JMP TMSCH,I   RETURN
* 
*     REMOVE PROGRAM FROM TIME LIST 
* 
CH040 LDA B10K      CLEAR THE RESOLUTION TOO. 
      STA B,I       AND RESET IN THE ID-SEGMENT.
      LDB POINT     VALUE OF TLINK
      JSB $TREM    GO TO REMOVE PROGRAM 
      JMP TMSCH,I   GO TO PROCESS NEXT PROGRAM
      HED REAL TIME CLOCK PROCESSING  ID-TIME UPDATE
*     TUDAT USES THE RES AND MULT FROM THE ID-SEGMENT TO
*     UPDATE THE EXECUTE TIME OF THE PROGRAM WHOES ID-
*     SEGMENT RESOLUTION CODE ADDRESS IS IN B.
* 
*     CALLING SEQUENCE: 
* 
*     SET TEMP TO THE MULT FACTOR 
*     SET B    TO THE RES CODE ADDRESS
*     JSB TUDAT 
* 
TUDAT DEF SETMS     ENTRY POINT 
      LDA B,I       GET THE RES CODE TO A 
      INB           SET 
      STB TEMP1     TEMPS TO THE TIME 
      INB           ADDRESSES 
      STB TEMP2     IN THE ID-SEGMENT 
      RAL,CLE,SLA,RAL IF HOURS
      JMP HR        GO DO SPECIAL HOURS UPDATE
      RAL,CLE       ELSE SET UP 
      AND D7        FOR THE APPROPIATE
      ADA TTAB      BASE
      LDA A,I       AND MULTIPLY BY THE MULT. 
CH030 MPY TEMP
CH031 ADA TEMP1,I   ADD THE CURRENT VALUE 
      SEZ           IF OVERFLOW 
      INB           STEP B
      ADB TEMP2,I   ADD THE HIGH BITS.
      STA TEMP1,I   RESTORE THE NEW TIME
      STB TEMP2,I   TO THE ID-SEG.
      CLE,SSB       IF NEGATIVE RESULT THEN 
      JMP TUDAT,I   EXIT
* 
      LDA RS1       POSITIVE RESULT SO ADD NEG. OF
      LDB RS2       DAY TO MAKE NEGATIVE
      JMP CH031 
* 
HR    LDA TEMP      FOR HOURS FIRST 
      CLB           INSURE LESS THAN
      DIV D24       ONE DAY 
      LDA B         RESULT IS MODULO 24 
      MPY D15       NOW SET UP TO MULTIPLY BY 60,000
      STA TEMP      IN TWO STEPS TO PREVENT OVERFLOW
      LDA D24K      FIRST BY 15,
      JMP CH030     AND NEXT BY 24,000
* 
$BATM NOP 
      NOP 
TLIST NOP          TOP OF TIME SCHEDULE LIST
$TIME OCT 16000     TIME OF DAT SET TO 8:00 AND 
      OCT 177650    DAY AND YEAR TO APPROX. 
DAYS  OCT 4552      RELEASE DATE. 
TTAB  DEF * 
TTAB1 DEC 1 
TTAB2 DEC 100 
TTAB3 DEC 6000
D24K  DEC 24000 
D2    DEC 2 
D7    DEC 7 
D14   DEC 14
D15   DEC 15
D16   DEC 16
D24   DEC 24
DM15  DEC -15 
      SPC 4 
* 
*     SYSTEM START TBG ROUTINE
* 
*     THE $SCLK ROUTINE STARTS THE CLOCK PROVIDES 
*     AN ENTRY POINT TO AID THE POWERFAIL ROUTINE.
* 
*     ON FIRST ENTRY THIS ROUTINE:
* 
*     1. CONFIGURES IT SELF 
*     2. STARTS THE TBG.
*     3. PRINTS "SET TIME"
*     4. EXITS TO THE DISPATCHER. 
* 
*     ON SUBSEQUENT ENTRIES IT IS A SUBROUTINE TO RESTART 
*     TIME BASE GENERATOR.
* 
$SCLK JMP CONFI     GO CONFIGURE ON FIRST ENTRY 
      LDA D2        PROGRAM THE TBG FOR 10'S OF MS. 
OTATB OTA 0 
STCTB OCT 1100      CONFIGURED TO A STC TBG,C 
STFTB OCT 1600      CONFIGURED TO A STF TBG 
      JMP $SCLK,I   RETURN
      SPC 2 
CONFI LDA TBG       CONFIGURE THE TBG 
TEMP  IOR OTATB     MAKE AN OTA TBG 
TEMP1 STA OTATB     SET IT
TEMP2 IOR STCTB     FORM AN STC TBG,C 
TCC   STA STCTB     SET THE STC 
      XOR STFTB     SET UP THE STF
      STA STFTB 
TLINC JSB $SCLK     START THE TBG 
POINT LDA TUDAT     SEND THE
DD.RT STB DD.RT     SAVE D.RTR ID-SEG. ADDRESS
      JSB $SYMG     SET TIME
      JMP $XEQ      MESSAGE AND GO TO THE DISPATCHER
      SPC 2 
SETMS DEC -10       LENGTH OF SET TIME MESSAGE
      OCT 6412      PUT CR/LF OUT FIRST 
      ASC 2,SET TIME
ATI   ASC 1,TI      TI USED BY BATCH TIMER
      HED $TIMV ROUTINE TO GET CURRENT SYSTEM TIME
*        THE $TIMV ROUTINE CONVERTS THE CURRENT REAL TIME VALUES    * 
*              AND STORES THE VALUES INTO A USER SPECIFIED BUFFER. *
*                                                                  *
*    ROUTINE TO PROVIDE CURRENT TIME
*         CALLING SEQUENCE
*              DLD TIME  PUT TIME IN A AND B REGS.
*              JSB $TIMV
*              RQP2 CONTAINS BEGIN ADDRESS OF 5 WORD BUFFER 
*              RQP3 (OPTIONAL) CONTAINS ADDRESS OF YEAR BUFFER
*         ON RETURN,
*              ARRAY(1) = TENS OF MILLISECOND 
*              ARRAY(2) = SECONDS 
*              ARRAY(3) = MINUTES 
*              ARRAY(4) = HOURS 
*              ARRAY(5) = DAYS
*              RQP3,I   = YEAR (197X) 
* 
*              E IS SET 
*              A IS THE YEAR
* 
$TIMV ASC 1,ME      ENTRY/EXIT (END OF SET TIME MSS.) 
      CLE           CLE FOR ADDITION
      ADA PRS1      ADD POSITIVE 24 HRS.
      SEZ           TO GET A POSITIVE 
      INB           TIME
      ADB PRS2
      DIV TTAB3     DIVIDE BY 6000
      STA RQP4      SAVE MIN/HR 
      ASR 16        POSITION B (SEC/10MS) FOR DIVIDE
      DIV TTAB2     DIVIDE BY 100 TO GET SEC/10MS 
      STB RQP2,I    SET 10MS VALUE
      ISZ RQP2      STEP ADDRESS POINTER
      STA RQP2,I    SET SEC. VALUE
      ISZ RQP2      STEP TO MIN. ADDRESS. 
      CLB           SET UP FOR DIVIDE 
      LDA RQP4      FETCH MIN/HR
      DIV D60       SEPERATE
      STB RQP2,I    SET MINUTES 
      ISZ RQP2      STEP TO HR. ADDRESS 
      STA RQP2,I    SET HRS 
      ISZ RQP2      STEP ADDRESS
      CLB           SET B FOR DIVIDE
      LDA $TIME+2   GET DAYS FORM THE TIME
      DIV D365      SEPERATE DAYS AND YEARS 
      CCE,INB       STEP DAYS TO 1-365 FROM 0-364 
      STB RQP2,I    SET DAYS
      ADA D1970     ADD THE BASE YEAR TO YEAR 
      STA RQP3,I    SET YEAR
      JMP $TIMV,I   RETURN
      SPC 2 
D60   DEC 60
D365  DEC 365 
D1970 DEC 1970      BASE YEAR 
DM197 DEC -1970     NEG OF BASE YEAR
      HED REAL TIME  ON REQUEST FOR TIME SCHED PROGRAM
*     ON REQUEST CONTINUATOR
* 
*     IF CURRENT TIME VALUES ARE ZERO OR NOW IS CODED THEN
*     THE CURRENT TIME IS PUT IN THE ID-SEG. AND R/M USED 
*     TO COMPUTE THE NEXT TIME. 
* 
*     IF CURRENT TIME VALUES ARE NOT ZERO THE PROGRAM IS
*     JUST PUT IN THE TIME LIST.
* 
*     CALLING SEQUENCE
* 
*     A=-1 IF NOW OPTION
*     A#-1 IF NOT NOW BUT PUT IN TIME LIST
*     B=ID-SEGMENT TIME ADDRESS.
* 
*     JMP $ONTM 
* 
$ONTM STB DLDAD     SET LOAD ADDRESS
      STA TCC       SET NOW FLAG FOR LATER
      INA,SZA,RSS   IF NOW SKIP LOAD
      JMP NOW 
      DLD DLDAD,I   GET THE CURRENT TIME VALUES 
DLDAD EQU *-1 
      SZA,RSS       IF TIME NOT ZERO
      SZB           THEN
      JMP TIMIN     THEN GO PUT IN TIME LIST
NOW   DLD $TIME     GET CURRENT TIME
      DST DLDAD,I   AND SET IN THE ID-SEG 
TIMIN LDB DM2       COMPUTE TIME LIST ADDRESS 
      ADB DLDAD     AND 
      STB POINT     AND SET FOR LIST ROUTINE
      JSB $TADD     ADD PROG TO TIME LIST.
      ISZ TCC       SKIP IF NOW 
      RSS 
      JSB TMSCH     SCHEDULE THE PROG. AND UPDATE 
MESEX CLA           SET A FOR NO ERROR
      LDB $MESS     GET RETURN ADDRESS
      JMP B,I       RETURN THRU $MESS ROUTINE 
      HED $TIMR ROUTINE SETS UP ID SEGMENT TIME VALUES
*        THE $TIMR ROUTINE WHICH ALLOWS USER TO ENTER TIME VALUES  *
*        INTO AN ID SEGMENT FUNCTIONS AS FOLLOWS:                  *
*              IF PROG VALUE IS ZERO, THEN CURRENT EXECUTING PROG. *
*                   AND IF NON-ZERO, THEN SEARCH FOR ID SEGMENT    *
*                   ADDRESS.                                       *
*              IF RESOLUTION CODE IS NON-ZERO, THEN RES/MULT WORD  *
*                   STORED. THE NEXT VALUE IS CHECKED FOR + OR -.  *
*                   IF PLUS, THEN NEXT START TIME VALUES GIVEN AND *
*                   ARE STORED AND PROGRAM ENTERED INTO TIME LIST. *
*                   IF MINUS, THEN THE COMPLEMENT OF VALUE IS ADDED*
*                   TO THE CURRENT TIME AND ENTERED INTO THE ID    *
*                   SEGMENT. IF PROG VALUE IS ZERO, THIS IS TO BE A*
*                   TIME DELAY OF CURRENT PROGRAM AND THUS PROGRAM *
*                   IS SET DORMANT VIA LINK PROCESSOR BUT POINT OF *
*                   SUSPENSION IS NOT CLEARED. IF PROG VALUE IS NON*
*                   ZERO, THEN PROGRAM IS ENTERED INTO TIME LIST.  *
*                   THIS IS METHOD FOR SPECIFYING AN INITIAL OFFSET*
*                   TIME.                                          *
* 
*     ROUTINE TO SET ID SEGMENT TIME VALUES 
*         CALLING SEQUENCE
*              JSB EXEC 
*              DEF *+6  OR DEF *+9
*              DEF  REQUEST CODE ADDRESS                   RQP1 
*              DEF  PROG                                   RQP2 
*              DEF  RES                                    RQP3 
*              DEF  MULT                                   RQP4 
*              DEF  OFFSET OR DEF HRS                      RQP5 
*                             DEF MINS                     RQP6 
*                             DEF SECS                     RQP7 
*                             DEF TENS OF MSEC             RQP8 
*         WHERE 
*              PROG = 0 IF CURRENTLY EXECUTING
*                   = ADDRESS OF PROGRAM NAME 
*              RES  = 1 FOR 10 MILLISECOND RESOLUTION 
*                   = 2 FOR SECONDS RESOLUTION LIST 
*                   = 3 FOR MINUTES RESOLUTION LIST 
*                   = 4 FOR HOURS RESOLUTION LIST 
*              MULT = 0 FOR N0 MULTIPLE VALUE 
*                   = N A POSITIVE INTEGER FOR COMPUTING
*                        NEXT SCHEDULE TIME 
*             OFFSET= M A NEGATIVE INTEGER FOR COMPUTING INITIAL
*                        OFFSET TIME
*                HRS= START TIME HOURS
*               MINS= START TIME MINUTES
*               SECS= START TIME SECONDS
*               TENS= START TIME TENS OF MILLISECONDS 
* 
*         EXEC PRE-PROCESSOR CHECKS FOR RESOLUTION CODE 
*         ERRORS AND FINDS THE ID-SEGMENT ADDRESS.
* 
*         CALLING SEQUENCE: 
* 
*         LDB ID-SEGMENT ADDRESS
*         JMP $TIMR 
      SKP 
$TIMR ADB D16       GET ADDRESS OF TIME LINK
      STB TCC       AND SAVE IT 
      INB           STEP TO RESOLUTION ADDRESS
      STB TEMP1     AND SAVE
      LDA B,I       GET RESOLUTION CODE/T/MULT
      INB           STEP TO TIME LOCATION 
      STB DSTAD     SAVE THE ADDRESS
* 
      ALF,ERA       SAVE BIT 12 SINCE PROGRAM MAY 
      LDA RQP4,I         ALREADY BE IN THE TIME LIST
      ALF,ERA       COMBINE MULT AND SAVED T-BIT
      LDB RQP3,I    RESOLUTION TO B 
      LSR 3         SHIFT RESULT TO A 
      STA TEMP1,I   SET IT IN THE ID-SEG. 
      LDA RQP5,I    NEGATIVE IF OFFSET
      SSA,RSS       POSITIVE IF START TIME
      JMP TI100 
      CMA,INA       SET POSITIVE AND
      STA TEMP      SAVE IN TEMP
      LDA RQP2,I   CHECK IF CURRENT XEQ PROGRAM 
      SZA 
      JMP TI012    NO 
* 
      LDB XEQT      YES, SET THE SAVE-
      STB $WORK      RESOURCES BIT IN 
      STA XEQT        THE PROGRAM'S STATUS
      ADB D15          WORD.
      LDA B,I       (CLEAR XEQT SO THAT $LIST WILL
      IOR B200       SET THE NP BIT IF THE USER IS
      STA B,I         MODIFING ITS ON TIME VALUES). 
      JSB $LIST     MAKE PROGRAM DORMANT
      OCT 300 
TI012 LDA $TIME     GET THE CURRENT TIME
      LDB $TIME+1   AND SET 
      DST DSTAD,I   IT IN THE ID-SEG
DSTAD EQU *-1 
      LDB TEMP1     GET THE RES. CODE ADDRESS TO B
      JSB TUDAT     UPDATE THE TIME 
* 
TI015 LDB TCC 
      JSB $TADD    ENTER PROG INTO TIME LIST
      JMP $XEQ       DONE - EXIT TO DISPATCHER
* 
*     GIVEN START TIME
* 
TI100 LDB DSTAD    SET B TO THE TIME ADDRESS AND
      JSB $ETTM    GO TO STORE VALUES IN ID SEGMENT 
      JMP TI015     GO PUT PROG IN TIME LIST
* 
DM2   DEC -2
B200  OCT 200 
      HED REAL TIME CLOCK PROCESSOR SET TIME IN ID-SEG
*     $ETTM SETS A TIME IN THE REFERENCED ID-SEGMENT. 
* 
*     CALLING SEQUENCE
* 
*     RQP5,I=HOURS
*     RQP6,I=MINUTES
*     RQP7,I=SECONDS
*     RQP8,I=TENS OF MS.
* 
*     B=TIME ADDRESS IN THE ID-SEG. 
* 
$ETTM NOP           ENTRY POINT 
      STB DSTA2     SAVE THE ID-SEG. ADDRESS
      LDA RQP7,I    GET SECONDS 
      MPY TTAB2     CONVERT TO MS (MPY D100)
      ADA RQP8,I    ADD THE MS VALUE AND
      STA RQP8      AND SAVE
      LDA RQP5,I    GET HOURS 
      MPY D60       CONVERT TO MINUTES
      ADA RQP6,I    ADD MINUTES 
      MPY TTAB3     CONVERT MINUTES TO MS (MPY D6000) 
      CLE           PREPARE FOR ADD 
      ADA RQP8      ADD MS VALUE
      SEZ           IF OVERFLOW 
      INB           STEP HIGH PART
SET01 CLE,SSB       IF POSITIVE 
      JMP SET02 
      ADA RS1       SUBTRACT 24 HRS 
      SEZ,CLE       UNTIL 
      INB 
      ADB RS2       IT IS 
      JMP SET01     NEGATIVE
SET02 DST DSTA2,I   SET THE VALUE IN THE ID-SEG.
DSTA2 EQU *-1 
      JMP $ETTM,I   RETURN
      HED ADDITION OF PROGRAM TO TIME RESOLUTION CODE LIST
*        THE $TADD ROUTINE FUNCTIONS AS FOLLOWS:                   *
*              IF RESOLUTION CODE IS ZERO, THEN EXIT               *
*              IF NON-ZERO RESOLUTION, AND PROGRAM NOT IN TIME LIST*
*                   (BIT 12 OF RES/T/MULT 0), THEN SET BIT 12 OF   *
*                   MULT WORD TO SIGNIFY THAT IT IS IN TIME LIST.  *
*                   IF TIME LIST IS NULL, THEN SET IT TO POINT TO  *
*                   PROGRAM TIME LINK AND SET TLINK TO ZERO.       *
*                   IF PROGRAM NOT IN LIST, THEN IT IS ADDED TO    *
*                        TOP OF TIME LIST AND ITS TLINK VALUE MADE *
*                        TO POINT TO THE PREVIOUS TOP OF LIST      *
*                        PROGRAM.                                  *
*                                                                  *
* 
*     ADDING A PROGRAM TO A TIME RESOLUTION CODE LIST 
*         CALLING SEQUENCE
*              LDB  ADDRESS OF ID SEGMENT TLINK VALUE 
*              JSB $TADD
* 
$TADD NOP 
      STB TLINC     SAVE TLINK ADDRESS
      INB           INCR TO RES CODE/MULT FACTOR ADD
      LDA B,I 
      ALF,CLE,ERA 
      AND D7
      SZA,RSS 
      JMP $TADD,I  EXIT 
      SEZ           PROG IN TIME LIST?
      JMP $TADD,I  YES, SO EXIT 
* 
      LDA B,I 
      IOR B10K     SET T BIT
      STA B,I 
      LDB TLIST     LOAD VALUE OF TOP OF LIST 
      LDA TLINC    SET LINK OF NEW PROG TO PREVIOUS 
      STB A,I           OF TIME LIST
      STA TLIST    SET TOP OF TIME LIST TO NEW PROG TLINK ADDRESS 
      JMP $TADD,I  RETURN 
      HED REMOVE A PROGRAM FROM TIME LIST 
*                                                                  *
*        THE $TREM ROUTINE FUNCTIONS AS FOLLOWS:                   *
*              IF PROGRAM NOT IN TIME LIST, THEN EXIT              *
*              IF PROGRAM IN TIME LIST, THEN CLEAR BIT 12 OF       *
*                   RES/T/MULT TO INDICATE NOT IN TIME LIST.       *
*                   A SEARCH IS MADE OF THE TIME LIST PROGRAMS     *
*                        UNTIL PROGRAM FOUND OR END OF LIST. THE   *
*                        TLINK VALUES ARE CHANGED AS NECESSARY.    *
*                                                                  *
* 
*         CALLING SEQUENCE
*              LDB  TLINK ADDRESS OF ID SEGMENT 
*              JSB $TREM
* 
$TREM NOP          ENTRY/EXIT 
      STB TLINC     COMPUTE LIST ADDRESS
      INB 
      LDA B,I      CHECK IF PROGRAM IS IN TIME LIST 
      AND B10K
      SZA,RSS 
      JMP $TREM,I  NO, SO EXIT
      XOR B,I       CLEAR T-BIT 
      STA B,I 
      LDA DTLST     GET ADDR OF TOP OF LIST PNTR
* 
TR010 LDB A,I       GET CURRENT TOP OF LIST 
      CPB TLINC     IS THIS THE PROG? 
      JMP TR030       YES 
      SZB,RSS       END OF LIST?
      JMP $TREM,I    YES, RETURN
      STB A         SAVE ADDR OF CURRENT LINKWORD 
      JMP TR010     GO CHECK NEXT PROG
* 
TR030 LDB B,I       LINK NEXT PROG
      STB A,I        TO PREV PROG TO REMOVE 
      JMP $TREM,I   RETURN
      SPC 1 
DTLST DEF TLIST 
B10K  OCT 10000 
      HED MESSAGE PROCESSOR TM REQUEST COMPLETION 
*     THIS ROUTINE COMPLETES THE SET TIME REQUEST 
* 
*     CALLING SEQUENCE: 
* 
*     LDB DEFP1     SET B TO ADDRESS OF PRAM LIST 
*     JMP $TMRQ 
* 
$TMRQ LDA DM6       SET UP PRAM ADDRESSES ON
      STA TEMP      THE BASE PAGE 
      LDA DRQP3 
TM1   STB A,I 
      ADB D4        PRAMS SEPERATED BY FOUR WORDS 
      INA 
      ISZ TEMP      DONE? 
      JMP TM1       NO
* 
      LDA RQP3,I    GET YEAR
      ADA DM197     SUBTRACT THE BASE 
      MPY D365      MULTIPLY BY DAYS PER YEAR 
      ADA RQP4,I    ADD THE DAY 
      CMB           SET B TO -1 IF LEGAL RESULT 
      ADA B         SUBRTACT ONE FROM DAY 
      INB,SZB       IF B WAS NOT ZERO AFTER MULT. THEN
      JMP $INER     INPUT ERROR 
      STA $TIME+2   SET DAY COUNTER 
* 
      LDB DTIME     GET TIME ADDRESS TO B 
      JSB $ETTM     SET THE TIME
      JMP MESEX     EXIT TO MESSAGE PROCESSOR 
      SPC 2 
DM6   DEC -6
DRQP3 DEF RQP3
D4    DEC 4 
DTIME DEF $TIME 
      HED ** SYSTEM BASE PAGE COMMUNICATION AREA ** 
* 
* 
*** SYSTEM BASE PAGE  COMMUNICATION  AREA *** 
* 
.     EQU 1650B     ESTABLISH ORIGIN OF AREA
* 
* SYSTEM TABLE DEFINITION * 
* 
EQTA  EQU .+0      FWA  OF  EQUIPMENT TABLE 
EQT#  EQU .+1       # OF EQT ENTRIES
* 
DRT   EQU .+2      FWA  OF  DEVICE REFERENCE TABLE
LUMAX EQU .+3       # OF LOGICAL UNITS (IN DRT) 
* 
INTBA EQU .+4      FWA  OF  INTERRUPT TABLE 
INTLG EQU .+5       # OF INTERRUPT TABLE ENTRIES
* 
TAT   EQU .+6      FWA  OF  TRACK ASSIGNMENT TABLE
* 
KEYWD EQU .+7      FWA  OF  KEYWORD BLOCK 
* 
* I/O MODULE/DRIVER COMMUNICATION 
* 
EQT1  EQU .+8      ADDRESSES
EQT2  EQU .+9 
EQT3  EQU .+10      OF
EQT4  EQU .+11
EQT5  EQU .+12      CURRENT 
EQT6  EQU .+13
EQT7  EQU .+14      15-WORD 
EQT8  EQU .+15
EQT9  EQU .+16      EQT 
EQT10 EQU .+17
EQT11 EQU .+18      ENTRY 
EQT12 EQU .+81
EQT13 EQU .+82
EQT14 EQU .+83
EQT15 EQU .+84
* 
CHAN  EQU .+19     CURRENT DMA CHANNEL #
TBG   EQU .+20     I/O ADDRESS OF TIME-BASE CARD
SYSTY EQU .+21     EQT ENTRY ADDRESS OF SYSTEM TTY
* 
* SYSTEM REQUEST PROCESSOR /'EXEC' COMMUNICATION *
* 
RQCNT EQU .+22     # OF REQUEST PARAMETERS -1 
RQRTN EQU .+23      RETURN POINT ADDRESS
RQP1  EQU .+24      ADDRESSES 
RQP2  EQU .+25
RQP3  EQU .+26       OF REQUEST 
RQP4  EQU .+27
RQP5  EQU .+28       PARAMETERS 
RQP6  EQU .+29
RQP7  EQU .+30       (SET FOR MAXIMUM OF
RQP8  EQU .+31        8 PARAMETERS) 
* 
* DEFINITION OF SYSTEM LISTS (QUEUES) * 
* 
DORMT EQU .+32     ADDRESS OF 'DORMANT' LIST, 
SKEDD EQU .+33      'SCHEDULE' LIST,
SUSP3 EQU .+36      'AVAILABLE MEMORY' LIST,
SUSP4 EQU .+37      'DISC ALLOCATION'  LIST,
SUSP5 EQU .+38      'OPERATOR SUSPEND' LIST 
* 
* DEFINITION OF EXECUTING PROGRAM  ID SEGMENT' *
* 
XEQT  EQU .+39     ID SEGMENT ADDR. OF CURRENT PROG.
XLINK EQU .+40       'LINKAGE'
XTEMP EQU .+41       'TEMPORARY (5-WORDS) 
XPRIO EQU .+46       'PRIORITY' WORD
XPENT EQU .+47       'PRIMARY ENTRY POINT'
XSUSP EQU .+48       'POINT OF SUSPENSION'
XA    EQU .+49       'A REGISTER' AT SUSPENSION 
XB    EQU .+50       'B REGISTER' 
XEO   EQU .+51       'E AND OVERFLOW
* 
* SYSTEM MODULE COMMUNICATION FLAGS * 
* 
OPATN EQU .+52     OPERATOR/KEYBOARD ATTENTION FLAG 
OPFLG EQU .+53     OPERATOR COMMUNICATION FLAG
SWAP  EQU .+54     RT DISC RESIDENT SWAPPING FLAG 
DUMMY EQU .+55     I/O ADDRESS OF DUMMY INT. CARD 
IDSDA EQU .+56     DISC ADDR. OF FIRST ID SEGMENT 
IDSDP EQU .+57      -POSITION WITHIN SECTOR 
* 
* DEFINITION OF MEMORY ALLOCATION BASES * 
* 
BPA1  EQU .+58     FWA R/T DISC RES. BP LINK AREA 
BPA2  EQU .+59     LWA R/T DISC RES. BP LINK AREA 
BPA3  EQU .+60     FWA BKG DISC RES. BP LINK AREA 
LBORG EQU .+61     FWA OF RESIDENT LIBRARY AREA 
RTORG EQU .+62     FWA OF REAL-TIME AREA
RTCOM EQU .+63     LENGTH OF REAL TIME COMMON AREA
RTDRA EQU .+64     FWA OF R/T DISC RESIDENT AREA
AVMEM EQU .+65     FWA OF SYSTEM AVAILABLE MEMORY 
BKORG EQU .+66     FWA OF BACKGROUND AREA 
BKCOM EQU .+67     LENGTH OF BACKGROUND COMMON AREA 
BKDRA EQU .+68     FWA OF BKG DISC RESIDENT AREA
* 
* UTILITY PARAMETERS
* 
TATLG EQU .+69     LENGTH OF TRACK ASSIGNMENT TABLE 
TATSD EQU .+70      # OF TRACKS ON SYSTEM DISC
SECT2 EQU .+71      # SECTORS/TRACK ON LU 2 (SYSTEM)
SECT3 EQU .+72      # SECTORS/TRACK ON LU 3 (AUX.)
* 
DSCLB EQU .+73     DISC ADDR OF RES LIB ENTRY PTS 
DSCLN EQU .+74      # OF RES LIB ENTRY POINTS 
DSCUT EQU .+75     DISC ADDR OF RELOC UTILITY PROGS 
DSCUN EQU .+76      # OF RELOC UTILITY PROGS
LGOTK EQU .+77     LOAD-N-GO: LU,STG TRACK,# OF TRKS
LGOC  EQU .+78      CURRENT LGO TRACK/SECTOR ADDRESS
SFCUN EQU .+79     SOURCE FILE LU AND DISC ADDRESS
MPTFL EQU .+80      MEMORY PROTECT ON/OFF FLAG (0/1)
FENCE EQU .+85      MEM PROTECT FENCE ADDRESS 
* 
BKLWA EQU .+87     LWA OF MEMORY IN BACKGROUND
* 
* 
FREG1 EQU LBORG 
FREG2 EQU RTORG 
FREG3 EQU BKORG 
FLG   EQU OPFLG 
* 
A     EQU 0B        LOCATION OF A REGISTER
B     EQU 1B        LOCATION OF B REGISTER
      ORG *         PROGRAM LENGTH
      END $SCLK 
                                                                                                                                      