.ENABLE LC ; ; PYRO.MAC ; ; Program pyrometric A/D monitor. ; ; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ; ~ LINK AS "LINK @PYRO.LNK" For 11M systems ~ ; ~ "LINK @PYRO11S.LNK" For 11S systems ~ ; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ; E.G. PYRO11S.LNK as follows: ; ; PYRO11S/-MM/PR,PYRO11S/-SP=PYRO ; LB:[1,60]SYSLIB/LB:ARITH ; LB:[1,60]KLABLIB/LB:KCOMM,LB:[1,60]KLABLIB/LB ; LB:[1,60]RSX11S.STB/SS ; LB:[1,60]EXELIB/LB ; LB:[1,60]SYSLIB/DL ; / ; PAR=GEN:41400:36300 ; TASK=PYRO ; ASG=TI:5 ; // ; ; The sweep routine sweeps 8 analogue channels on every clock overflow ;(every 0.625 secs). ; It generates an AST every 10 secs with 128 words of channel data. The ; resultant channels are averaged over the 10 sec period, placed in a 256 wd ; output buffer (obuf) and when full, written to TU58 tape. ; ; Radiation and sun are recorded only if ; a. 6:30 < Time < 19:00 ; OR ; b. A sun recording (ch #0) is registering above 10 MV (4121) ; ; TU58 BLOCK LAYOUT ; ; BLOCK 0 (created by PYTAPE) ; ; WD 0 = CASSETTE SEQUENCE NUMBER ; WD 1 = RECORDING INTERVAL (SECS) ; WD 2 = +&- A/D RANGE IN MILLI-VOLTS ; BYTE 6-12. = NAME (10 CHARACTERS) ; ; BLOCKS 1-511. ; ; WD 0 =DATE 15 8 4 0 ; ------------- ; ! Y ! M ! D ! ; ------------- ; ; WD 1 = TIME 15 12 5 0 ; ------------- ; ! ! H ! M ! ; ------------- ; ;WD 2 = ADDR LAST BLK 15 0 (word address) ; ------------- ; ! ! ; ------------- ; ;WD 3-511. = DATA 15 14 0 15 14 11 0 ; ------------- -------------- ; !F1! #INCS ! !F2! CH! VAL ! ; ------------- -------------- ; Where: ; F1 = 1 ; F2 = 0 ; #INCS = # 10 sec increments (keeps incrementing until overflow) ; CH = Channel number ; VAL = Raw channel word. ; ; Aditional logic is present to : ; a. Output a voltage to display TU58 tape usage ; b. Output voltages to display error conditions. ; c. Input digital signals to sense: ; (i) Cassette dismount ; (ii) Reload new cassette and zero block number. ; (iii) Reset error display ; The following digital bit map describes these inputs. ; ; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ; ~ Condition Data-in word ~ ; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ; ~ Switch = RELOAD ~ Set bit 0, Set bit 1 ~ ; ~ Switch = RUN ~ Set bit 0, Clear bit 1 ~ ; ~ Cassette IN ~ Set bit 0, clear bit 2 ~ ; ~ Cassette OUT ~ Set bit 0, Set bit 2 ~ ; ~ Reset error dsply ~ Set bit 0, Set bit 3 ~ ; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ; ; ; OUTPUT BINARY CODES are for display purposes: ; ; ___________________ _______ ; ! ! ! ! ! ! _____ ; ! 2 ! 5 ! 1 ! ! 0 ! !LED! ; ! ! ! ! ! ! ----- ; ------------------- ------- ; ^ ^ ^ ; (LBN) (ERR) (RUN) ; ; Codes are output in BCD as follows ; ; (LBN) msd (2) = bits ( 8-10) ; (LBN) mid (5) = bits ( 4-7 ) ; (LBN) lsd (1) = bits ( 0-3 ) ; (ERR) dig (0) = bits (11-14) ; (RUN) = bit (15) ; ; ; ***************** ERROR DISPLAY CODES ******************** ; ; CODE MEANING ; 1 Tape is out without LOAD being switched. ; 2 Block count=500+ warning. ; 3 Tape out or switch wrong - recover by correcting problem. ; 4 Warning tape error will retry when RESET hit. ; 5 Block count >510 must load new tape and RESET. ; Fatal tape error - data is being lost ; 6 New tape loaded without LOAD switch being activated. ; - recover by changing back to OLD tape and RESET. ; 7 Same tape loaded after "new tape" load sequence executed. ; - hit RESET to continue output without LBN being initialized. ; 8 A/D Sweep error - retry on RESET. ; 9 Unknown digital interrupt. ; ; Event Flag = 23 implies A/D sweep error retry on RESET ; ; .NLIST .IDENT /M01.00/ ; ; COPYRIGHT (C) 1977, 1978 ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY ON A ; SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE, OR ; ANY OTHER COPIES THEREOF, MAY NOT BE PROVIDED OR OTHERWISE ; MADE AVAILABLE TO ANY OTHER PERSON EXCEPT FOR USE ON SUCH ; SYSTEM AND TO ONE WHO AGREES TO THESE LICENSE TERMS. TITLE ; TO AND OWNERSHIP OF THE SOFTWARE SHALL AT ALL TIMES REMAIN ; IN DEC. ; ; THE INFORMATION IN THIS DOCUMENT IS SUBJECT TO CHANGE WITHOUT ; NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL ; EQUIPMENT CORPORATION. ; ; DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ; ITS SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC. ; ; MACROS TO FACILITATE CALLING FORTRAN SUBROUTINES FROM MACRO-11. ; ; VERSION 01 ; C. D'ELIA 17-NOV-77 ; ;+ ; INITS -- INITIALIZE FOR STRUCTURED FORTRAN CALL MACROS ; ; CALLING SEQUENCE: ; ; INITS ; ; EFFECTS: ; ; SETS THE GLOBAL LISTING FLAG ; SETS THE ASSEMBLER PASS FLAG ; ;- .MACRO INITS LST=0 $LST=LST .IF NDF $PASS $PASS=0 .IFF $PASS=1 .ENDC .ENDM ;+ ; CALLS -- CALL FORTRAN SUBROUTINE ; ; CALLING SEQUENCE: ; ; CALLS SUBR, ; ; WHERE: ; ; SUBR IS THE SUBROUTINE TO CALL ; ; ARG1,..ARGN ARE THE ARGUMENTS TO PASS TO THE SUBROUTINE. ; THEY MAY EITHER BE CONSTANTS (1,5,8,12,ETC.-- ; TAKEN AS DECIMAL NUMBERS ("." APPENDED)) ; OR MEMORY LOCATIONS (IDATA, BUF, ETC.). ; IF AN ARGUMENT IS DEFAULTED (",,") A ; MINUS 1 (177777) WILL BE INSERTED FOR THE ; ARGUMENT ADDRESS (FORTRAN STANDARD). ; ; EXAMPLES: ; ; CALLS SUB1,<5,18,ARG3> ; CALLS SUB2, ; CALLS SUB3,<,,,IOUT> ; ;- .MACRO CALLS SUBR,ARGLST .PSECT $ARGL$ $$1=. .BLKB 2 $NARG=0 .IRP X, .IF B .WORD 177777 .IFF .NTYPE $T,X .IF NE $T-67 .ERROR X ;INVALID ARGUMENT .MEXIT .ENDC GENARG X .ENDC $NARG=$NARG+1 .ENDM $$2=. .=$$1 .BYTE $NARG,0 .=$$2 .PSECT .IIF GT $LST, .LIST MOV #$$1,R5 JSR PC,SUBR .IIF GT $LST, .NLIST .ENDM .MACRO GENARG ARG .IF DF $C'ARG .WORD $C'ARG .PSECT $CONS$ .IF EQ .-$C'ARG $C'ARG: .WORD ARG'. .ENDC .PSECT $ARGL$ .IFF .IF NDF $PASS .ERROR ;FAILED TO CALL "INITS" .MEXIT .ENDC .IF EQ $PASS TSTARG ARG,\ARG .IFF .WORD ARG .ENDC .ENDC .ENDM .MACRO TSTARG SYM,VAL .IF IDN , .PSECT $CONS$ $C'SYM: .WORD SYM'. .PSECT $ARGL$ .WORD $C'SYM .IFF .WORD SYM .ENDC .ENDM .LIST ; ; ; START OF PYRO MAINLINE ; ; ;Flag word offsets (DFLG) ; RLD=1 ;Set=rld, Clear=run COL=2 ;Cassette Out with Load switch COR=4 ;Cassette Out with Run switch DAY=10 ;Set=daytime, Clear=Night ERR=20 ;Set=error, Clear=noerror WAIT=40 ;Set=cass output ready DLOSS=100 ;Set=data being lost WR=200 ;Set=eof ,Clear=data write AER=400 ;A/D Sweep error DCA=1000 ;Display channels command is active NEG=2000 ;Negative value in integer arith. BADT=4000 ;Bad tape process name PROM=10000 ;Terminal prompt been issued BYTEN=20000 ;If a/d range <2500mv display X10 ; ; ;LED Display flag offsets (LEDFLG) ; LRUN=1 ;A RUN flash LERR=2 ;An ERROR display LLBN=4 ;An LBN display LFDIG=10 ;First digit flag LRSET=20 ;Led reset flag ; ; ; .ENABL LC .MCALL SETF$S,WTSE$S,WSIG$S,EXIT$S,GTIM$S,ASTX$S,QIO$S,ALUN$S .MCALL STIM$S,QIOW$S,MRKT$S START: INITS CLC ; JSR PC,DATIM ;Get and set Time & Date BCS START ; BIS #LRSET!LERR!LLBN,LEDFLG ;Reset error+lbn display JSR PC,FLASH DIN: CALLS DINP,<0,,BIN2,DWD1> ;get logger status ASR DWD1 ; BIT #COL!COR!RLD,DWD1 ;Ready to go ?? BEQ 5$ ; BIS #LERR,LEDFLG ;No MOV #3,R1 ;*** ERR = 3 *** JSR PC,FLASH ; BR DIN ;Try again 5$: ALUN$S #1,#"DD,#0 ;Assign #1 to DD0: ; ; Read cassette block 0 ; 10$: QIOW$S #IO.RLB,#1,#1,,#TUSTAT,,<#TUBLK,#14.,,,#0> JSR PC,CHEKT ;Check process name BCC 20$ ; BIS #LERR,LEDFLG ;Wrong tape CLR R1 ; JSR PC,FLASH ;**** ERR = 0 ***** MRKT$S #1,#3,#2 ;Wait 3 sec WTSE$S #1 ; BR 10$ ;Try again 20$: MOV TUBLK,CASNUM ; MOV #" ,DCHED+36. ; MOV #" ,DCHED+38. ; BIC #BYTEN,DFLG ; CMP TUBLK+4,#2500. ;A/D range < 2500 mv ? BGE 30$ ; BIS #BYTEN,DFLG ;Yes set flag MOV TENM,DCHED+36. ;Put X10 in header MOV TENM+2,DCHED+38. ; 30$: MOV TUBLK+4,ARANGE ;Remember A/D range BIS #LRSET!LERR,LEDFLG ;Clear error display JSR PC,FLASH ; CALLS SETIBF, ;Initiliaze analogue buffers CALLS SETIBF, ;Initialize digio buffers CALLS CLOCKA,<3,IPRSET,IST> ;Set clock O/Flow rate CALLS RLSBUF, ; ; ; Start one channel digital I/O sweep ; CALLS DISWP, ; BIS #PROM,DFLG ; QIO$S #IO.RPR,#5,#1,,#TSTAT,#TERMI,<#CMD,#10.,,#PRMT,#5,#0> ST1: MOV #OBUF1,OBCUR ; CLR OBFR ; MOV #OBUF2,OBFR+2 ; MOV #OBUF1,OBUSD ; CLR OBUSD+2 ; CALLS RLSBUF, ; JSR PC,TSTAMP ;Time stamp the cassette ; ; Start infinite A/D sweep of 8 channels. ; CALLS ADSWP, WTSE$S #23. ; BR ST1 ;If A/D error reset all ; ; ; Terminal I/O Service Routine ; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ; ; TERMI: CMPB #IE.ABO,TSTAT ;I/O Killed ? BNE 5$ ; JSR PC,DSPLAY ;Yes - time to display chans QIO$S #IO.WLB,#5,#1,,,#TERTN1,<#DCBUF,#56.> JMP TERTN ; 5$: BIC #PROM,DFLG ; TST TSTAT+2 ;Any data ? BNE 20$ ; JMP TERTN1 ;No - exit. 20$: MOV #CMD,R0 ; MOV R0,R1 ; MOV #2,R2 ; CALL $CVTUC ;Convert to UC CMP CMD,#"LC ;List Channels command ? BEQ LC ; CMP CMD,#"SC ;Set Channel command ? BNE 10$ ; JMP SC ; 10$: CMP CMD,#"DC ;Display channel cmd ? BNE 30$ ; JMP DC ; 30$: CMP CMD,#"ED ;End Display cmd ? BNE 40$ ; JMP ED ; 40$: QIO$S #IO.WLB,#5,#1,,,#TERTN1,<#INVAL,#19.> JMP TERTN ; LC: QIO$S #IO.WLB,#5,#1,,,#5$,<#LCBUF,#12.> JMP TERTN ; 5$: MOV #CHAMAP,R3 ; CLR R5 ; 10$: CLR R2 ; MOV #12.,LCL ; MOV #LCBUF+16.,R0 ; MOV R5,R1 ; CALL $CBDMG ;Convert chan # to ASCII MOVB (R3),LCBUF+22. ; CMPB (R3)+,#'T ;Time channel ? BNE 20$ ; MOV #5,R0 ; MOV R5,R1 ; CALL $MUL ;Calc offset into ascii time table MOV R1,BIN1 ; ADD #TSBUF,R1 ;Adrress of ascii field MOV #TBUF+2,R4 ; MOV #5,R0 ; 30$: MOVB (R1)+,(R4)+ ;Start time to message DEC R0 ; BNE 30$ ; MOVB #' ,(R4)+ ; MOVB #'-,(R4)+ ; MOVB #' ,(R4)+ ; MOV BIN1,R1 ;Retrieve offset ADD #TEBUF,R1 ; MOV #5,R0 ; 40$: MOVB (R1)+,(R4)+ ;End time to message DEC R0 ; BNE 40$ ; MOV #28.,LCL ; 20$: QIO$S #IO.WLB,#5,#1,,,#50$,<#LCBUF+12.,LCL> JMP TERTN ; 50$: INC R5 ; CMP R5,#8. ; BNE 10$ ; JMP TERTN1 ; SC: MOV #CMD+2,R0 ; MOVB CMD+2,OPMES+28. ;Get channel # to set CMPB CMD+2,#' ; BNE 10$ ; MOV #CMD+3,R0 ; MOVB CMD+3,OPMES+28. ; 10$: CALL $CDTB ;To binary CMP R1,#8. ; BMI 30$ ; QIO$S #IO.WLB,#5,#1,,,#TERTN1,<#CHERR,#19.> JMP TERTN ; 30$: MOV R1,R5 ;For safe keeping MOV R5,R4 ;Channel # ASL R4 ;X 2 Channel offset QIO$S #IO.WLB,#5,#1,,,#110$,<#OPMES,#32.> ;Ask fo options JMP TERTN ; 110$: QIO$S #IO.RLB,#5,#1,,,#120$,<#CMD,#1> JMP TERTN ; 120$: MOV #CMD,R0 ; MOV R0,R1 ; MOV #1,R2 ; CALL $CVTUC ; CMPB CMD,#'O ;Channel off ? BNE 60$ ; JMP 20$ ; 60$: CMPB CMD,#'T ;Time based collection ? BEQ 70$ ; JMP 80$ ; 70$: QIO$S #IO.WLB,#5,#1,,,#130$,<#TSTRT,#29.> ;Ask for start time JMP TERTN ; 130$: QIO$S #IO.RLB,#5,#1,,#TSTAT,#160$,<#CMD,#5> JMP TERTN ; 160$: MOV #TSBUF,R3 ; JSR PC,PUTIM ;Put ascii time into save buffer MOV #CMD,R0 ; JSR PC,TIMC ;Convert time to integer (hrsXmins) BCC 100$ ; JMP TERTN1 ; 100$: MOV R1,TSMAP(R4) ;Plug start time in map QIO$S #IO.WLB,#5,#1,,,#140$,<#TEND,#29.> ; Ask for end time JMP TERTN ; 140$: QIO$S #IO.RLB,#5,#1,,#TSTAT,#150$,<#CMD,#5> JMP TERTN ; 150$: MOV #TEBUF,R3 ; JSR PC,PUTIM ;Save ascii time MOV #CMD,R0 ; JSR PC,TIMC ; BCC 40$ ; 50$: CLR TSMAP(R4) ;On error reset start time CLR TEMAP(R4) ; MOVB #'O,CHAMAP(R5) ; QIO$S #IO.WLB,#5,#1,,,#TERTN1,<#TVERR,#20.> JMP TERTN ; 40$: CMP R1,TSMAP(R4) ; BLE 50$ ; MOV R1,TEMAP(R4) ;Plug end time MOVB #'T,CHAMAP(R5) ; BR TERTN1 ; 80$: CMPB CMD,#'S ;Sun based collection ? BEQ 20$ ; CMPB CMD,#'C ;Continuous collection ? BEQ 20$ ; CMPB CMD,#'L ;sun LIGHT channel ? BNE 90$ ; MOV R5,SUNC ;Yes - remember channel number 20$: MOVB CMD,CHAMAP(R5) ; CLR TSMAP(R4) ; CLR TEMAP(R4) ; BR TERTN1 ; 90$: QIO$S #IO.WLB,#5,#1,,,#TERTN1,<#INVAL,#19.> JMP TERTN ; DC: QIO$S #IO.WLB,#5,#1,,,#10$,<#DCHED,#106.> JMP TERTN ; 10$: JSR PC,DSPLAY ;Format record for display QIO$S #IO.WLB,#5,#1,,,#TERTN1,<#DCBUF,#56.> BIS #DCA,DFLG ; JMP TERTN ; ED: BIC #DCA,DFLG ; JMP TERTN1 ; TERTN1: QIO$S #IO.WLB,#5,#1,,,#10$,<#OPMES,#2> JMP TERTN 10$: MOV #" ,CMD ; MOV #" ,CMD+2 ; MOV #" ,CMD+4 ; BIS #PROM,DFLG ; QIO$S #IO.RPR,#5,#1,,#TSTAT,#TERMI,<#CMD,#10.,,#PRMT,#5,#0> TERTN: TST (SP)+ ASTX$S ; ; ; ; Analogue sweep service routine ; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ; ; ASERV: TST IBUF ;A/D in good shape ? BEQ 5$ ; BIS #LERR,LEDFLG ;HELL NO we are in trouble MOV #8.,R1 ; JSR PC,FLASH ;Flash error to confuse everyone BIS #AER,DFLG ;Set a/d error flag JMP ASDONE ;Wait for RESET 5$: MOV #100000,R1 ; BIS #LRUN,LEDFLG ; JSR PC,FLASH ;Flash the run LED GTIM$S #DATBUF ;Read the time BIC #DAY,DFLG ; CMP DATBUF+G.TIHR,#6 ;Time to record ? BLT 10$ ; CMP DATBUF+G.TIHR,#19. ;Time to shut down ? BGE 10$ ; BIS #DAY,DFLG ;Record as day time 10$: CALLS IGTBUF, ; MOV IBUFNO,R2 ;Get buffer # ASL R2 ; MOV BUFLST(R2),CURRB ;Update as current buffer ; ; Clear the work area ; MOV #WORK+2,R1 ; 20$: CLR (R1)+ ; CMP R1,#WORK+18. ; BNE 20$ ; CLR TEMP ; CLR NCHNS ; ; ; Integrate sun readings ; MOV SUNC,R2 ;Get channel light monitor ASL R2 ; ADD CURRB,R2 ;Offset to it. MOV TOTCHNS,R4 ; ASL R4 ;Size of channel grouping MOV BSZ,R0 ; MOV TOTCHNS,R1 ; CALL $DIV ;Number of channel groups MOV R0,GRPS ; MOV R0,R3 ; 30$: ADD (R2),TEMP ;Accumulate sun data DEC R3 ; ADD R4,R2 ;skip to next group TST R3 ; BNE 30$ ; MOV TEMP,R0 ; MOV GRPS,R1 ; CALL $DIV ;Average the sun reading CMP R0,#4121 ;Any light about ? BLE 40$ ; BIS #DAY,DFLG ;Yes - remember for later ; ; Accumulate "S"un , "T"ime and "C"ontinuous data ; 40$: MOV CURRB,R2 ; MOV GRPS,R3 ;Counter for 16 groups 45$: CLR R1 ;Byte counter MOV #2,R0 ;word counter for 8 chans 50$: CMPB CHAMAP(R1),#'C ;Continuous monitor chan ? BEQ 60$ ; CMPB CHAMAP(R1),#'S ;No - SUN monitor chan ? BEQ 55$ ; CMPB CHAMAP(R1),#'L ; BNE 100$ ; 55$: BIT #DAY,DFLG ;Yes - time to collect ? BNE 60$ ;No - must be night 100$: CLC ; JSR PC,TSTIME ;Go test TIME monitor BCC 80$ ; 60$: ADD @R2,WORK(R0) ;Accumulate data CMP GRPS,R3 ; BNE 80$ ; INC NCHNS ; 80$: INC R1 ; INC R2 ; INC R2 ; INC R0 ; INC R0 ; CMP TOTCHNS,R1 ;Last channel ? BNE 50$ ; DEC R3 ;Yes - decrement group counter BNE 45$ ; ; ; Integrate collected readings ; MOV TOTCHNS,R4 ; MOV #WORK+2,R3 ; 90$: MOV @R3,R0 ; MOV GRPS,R1 ; CALL $DIV ;Take an average MOV R0,(R3)+ ;Pop result back to work DEC R4 ; BNE 90$ ; ; ; Timer management ; TIMER: INC TIM ;Add another tic to the fire MOV TIM,WORK ; CMP #32767.,TIM ;Last one ? BNE 10$ ; CLR TIM ;Yes - reset tics BR 20$ ; 10$: TST NCHNS ;Any cannels to write ? BNE 20$ ; JMP ASDONE ;No - go wait for next lot ; ; Outblock manager ; 20$: MOV NCHNS,R1 ; INC R1 ;Allow fo tic wd. ASL R1 ; MOV #512.,R2 ; SUB OBWD,R2 ; CMP R2,R1 ;Room for this data ? BLT 40$ ;No - we will hanle this later JSR PC,MVDATA ;Move data to outblock JMP ASDONE ; 40$: CLR R1 ; DEC OBWD ; DEC OBWD ; ASR OBWD ;Record last block as wd pointer MOV OBCUR,R0 ; MOV OBWD,4(R0) ;Update for last blk addr. BIT #DLOSS,DFLG ;Cleared overful tape yet ? BNE 30$ ;NO - reset all blocks MOV OBFR,R2 ;YES - Look for free block BNE 50$ ;Got first one ADD #2,R1 ; MOV OBFR+2,R2 ; BNE 50$ ;Got second one ;Christ! - there are none left. 30$: BIC #WAIT,DFLG ;Dont attempt buffer recovery. BIS #DLOSS,DFLG ;Set data lost flag BIC #ERR,DFLG ;Clear outstanding err MOV #5,R1 ;**** ERR=5 **** BIS #LERR,LEDFLG ; JSR PC,FLASH ; MOV #OBUF1,OBCUR ;Reset buffer management CLR OBFR ; MOV #OBUF2,OBFR+2 ; MOV #OBUF1,OBUSD ; CLR OBUSD+2 ; JSR PC,TSTAMP ; JSR PC,MVDATA ; JMP ASDONE ; 50$: MOV OBCUR,TUBUF ;Address the block to write CLR OBFR(R1) ;Map new buffer as not free MOV R2,OBUSD(R1) ;Also map it as "in use" CLR OBWD ;Reset outblk word pointer MOV R2,OBCUR ;Set new blk as current JSR PC,TSTAMP ;Time stamp new block JSR PC,MVDATA ;Drop latest data into it CASWR: BIT #RLD!COL!COR!ERR,DFLG ;Clear to write ? BEQ 5$ ; BIS #WAIT,DFLG ;No - set I'm waiting flag MOV #3,R1 ;**** ERR=3 ***** BIS #LERR,LEDFLG ; JSR PC,FLASH ; JMP ASDONE ; 5$: BIC #WAIT,DFLG ; JSR PC,WRITE ;Write block ; ; ASERV Exit ; ASDONE: BIT #DCA,DFLG ;Display chans active ? BEQ 20$ ; BIT #PROM,DFLG ;Read outstanding ? BNE 10$ ; QIO$S #IO.WLB,#5,#1,,,#TERTN1,<#DCBUF,#56.> ;No - write data now BR 20$ ; 10$: QIO$S #IO.KIL,#5 ;Yes - kill termio and wait 20$: CALLS RLSBUF, ; RTS PC ; ; ; DIGITAL I/O Service routine ; ~~~~~~~~~~~~~~~~~~~~~~~~~~~ ; ; DSERV: CALLS IGTBUF, ;Get buffer number MOV DBUFNO,R1 ; ASL R1 ; ADD #DWD1,R1 ;Get actual buffer BIT #177720,@R1 ;Illegal bits ? BEQ 10$ ; MOV #1,R5 ; MOV #9.,R1 ;Yes - Set ****ERR=9**** BIS #LERR,LEDFLG ; JSR PC,FLASH ;Display error JMP DIGEX ;Exit 10$: MOV LASTD,DOP ;Last interupt word to ops MOV @R1,LASTD ; MOV @R1,R2 ; XOR R2,DOP ;Get interrupt bit MOV DOP,R2 ; MOV R2,R3 ; BNE 20$ ; JMP DIGEX ;If no change exit. 20$: ASR R3 ; BIC #1,R3 ; JMP @DROUT(R3) ;Go to interrupt handler ; RELOAD: BIT R2,@R1 ;Run or Reload ? BEQ RUN ; BIS #RLD,DFLG ;Set reload bit JMP DIGEX ; ; RUN: BIC #RLD,DFLG ;Clear reload flag JMP DIGEX ; ; CASIN: BIT R2,@R1 ;Casin or out ? BEQ 10$ ; JMP CASOUT ; ; Read Block 0 10$: MRKT$S #1,#1,#2,#CREAD ;Wait 1 sec for tape to seat. JMP DIGEX ; CREAD: QIO$S #IO.RLB,#1,#1,,#TUSTAT,#5$,<#TUBLK,#12.,,,#0> JMP DIGEX1 ; 5$: JSR PC,CHEKT ;Correct tape ? BCC 50$ ; BIS #BADT!ERR,DFLG ;No BIC #COR!COL,DFLG ; JMP DIGEX1 ; 50$: BIC #BADT,DFLG ; BIT #COL,DFLG ;Normal load ? BEQ 10$ ; BIC #COR,DFLG ;YES - clean up old flags CMP TUBLK,CASNUM ;New cassette ? BNE 20$ ; MOV #7,R1 ;No - must be changed BIS #LERR,LEDFLG ; JSR PC,FLASH ;**** ERROR 7 **** BIC #COL,DFLG ; BIS #ERR,DFLG ; JMP DIGEX1 ;Dont reset LBN 20$: MOV #1,LBN ; BIC #DLOSS,DFLG ; MOV TUBLK,CASNUM ; MOV #" ,DCHED+36. ; MOV #" ,DCHED+38. ; BIC #BYTEN,DFLG ; CMP TUBLK+4,#2500. ;A/D range < 2500 mv ? BGE 25$ ; BIS #BYTEN,DFLG ;Yes set flag MOV TENM,DCHED+36. ;Put X10 in header MOV TENM+2,DCHED+38. ; 25$: MOV TUBLK+4,ARANGE ; BIC #COL,DFLG ; JMP DIGEX1 ; ; Changed cassette without LOAD switch ON - naughty 10$: CMP TUBLK,CASNUM ;Same cassette ? BNE 30$ ; BIC #COR,DFLG ;Yes - just ignore BIS #ERR,DFLG ;Wait for RESET to continue JMP DIGEX1 ; 30$: MOV #6,R1 ;Different cassette BIS #LERR,LEDFLG ; JSR PC,FLASH ;**** ERROR 6 **** JMP DIGEX1 ;Wait for old cassette ; ; CASOUT: BIT #RLD,DFLG ;Reload switch on ? BNE 10$ ; BIS #ERR!COR,DFLG ;No - set flag BIS #LERR,LEDFLG ; MOV #1,R1 ;Set *** ERR=1 *** JSR PC,FLASH ;Display it BR 20$ ; 10$: BIS #COL,DFLG ; 20$: JMP DIGEX ; ; RESET: BIT #COL!COR!DLOSS!BADT,DFLG ;Is cass out OR data being lost ? BEQ 10$ ; JMP DIGEX ;Yes - dont reset error 10$: BIC #ERR,DFLG ;No - reset err flag BIS #LRSET!LERR,LEDFLG ; JSR PC,FLASH ;Reset error display BIT #AER,DFLG ;Analog error ? BEQ DIGEX ; SETF$S #23. ;Yes - set EF=23. JMP DIGEX ; ; DIGEX1: TST (SP)+ ; ASTX$S ; DIGEX: CALLS RLSBUF, ; BIT #WAIT,DFLG ;Cass output waiting ? BEQ 10$ ; BIT #RLD!COL!COR!ERR,DFLG ;Clear to write ? BNE 10$ ; BIC #WAIT,DFLG ;Yes JSR PC,WRITE ;Go do it. 10$: RTS PC ; ; ; ; ********************************* ; * SUBROUTINE WRITE (tu58 blk) * ; ********************************* ; ; WRITE: CMP LBN,#511. ;Room on tape for two blocks ? BLT W1 ; BIT #DLOSS,DFLG ;Data loss flag up ? BNE W2 ;Yes - maintain that status BIS #LERR,LEDFLG ;No - into Error logic MOV #4,R1 ; JSR PC,FLASH ;***** ERROR 4 ****** BIS #ERR!WAIT,DFLG ; BR W2 ; W1: QIO$S #IO.WLB,#1,#1,,#TUSTAT,#TUFIN, W2: RTS PC ; ; ; ; ******************************* ; * TU58 AST ENTRY ROUTINE * ; ******************************* ; ; TUFIN: ;AST entry on write finished CMP #IS.SUC,TUSTAT ; BEQ 10$ ; BIT #DLOSS,DFLG ;If data loss flag is up BNE 5$ ;Dont change error status MOV #4,R1 ; BIS #LERR,LEDFLG ; BIS #ERR!WAIT,DFLG ; JSR PC,FLASH ;Cass error **** ERR=4 **** 5$: JMP 40$ ;Will retry when RESET hit. 10$: MOV #WR,R1 ; XOR R1,DFLG ;Flip the write flag BIT #WR,DFLG ;Data write done ? BEQ 50$ ; MOV TUBUF,R0 ;Yes - eof comming up CLR 4(R0) ; MOV LBN,R1 ; BIS #LLBN,LEDFLG ; JSR PC,FLASH ;Display last LBN in leds. INC LBN ; JSR PC,W1 ; JMP 40$ ; 50$: CLR R2 ; CMP TUBUF,OBUSD ;Find this buffer in map BEQ 60$ ; ADD #2,R2 ; 60$: CLR OBUSD(R2) ;Take it off used map MOV TUBUF,OBFR(R2) ;Free it up CMP LBN,#501. ;Near Last cass blk ? BLT 40$ ; MOV #2,R1 ;Hell - yes *** ERR=2 *** BIS #LERR,LEDFLG ; JSR PC,FLASH ; 40$: TST (SP)+ ; ASTX$S ; ; ; ; ********************************* ; * SUBROUTINE TSTAMP (timestamp) * ; ********************************* ; TSTAMP: GTIM$S #DATBUF ;Read the time MOV DATBUF+G.TIDA,@OBCUR ;Put day in buffer MOV DATBUF+G.TIMO,R3 ;Get month MOV #5,R4 ; 10$: ASL R3 ;Position it DEC R4 ; BNE 10$ ; BIS R3,@OBCUR ;'OR' month into wd. MOV #9.,R4 ; MOV DATBUF+G.TIYR,R3 ;Get year 20$: ASL R3 ;Position it DEC R4 ; BNE 20$ ; BIS R3,@OBCUR ;'OR' year into wd. MOV OBCUR,R0 ; MOV DATBUF+G.TIMI,2(R0) ;Get minutes MOV DATBUF+G.TIHR,R3 ;Get hrs MOV #6,R4 ; 30$: ASL R3 ;Position it DEC R4 ; BNE 30$ ; BIS R3,2(R0) ;'OR' hrs into wd CLR 4(R0) ; MOV #6,OBWD ;Position to 1st avail wd. RTS PC ; ; ; ; ; ; **************************************************** ; * SUBROUTINE MVDATA (format & move data to outblk) * ; **************************************************** ; MVDATA: MOV OBCUR,R1 ; ADD OBWD,R1 ; BIS #100000,WORK ;Set time flag CLR R2 ; MOV #WORK,R3 ; MOV (R3)+,(R1)+ ; INC OBWD ; INC OBWD ; 24$: TST @R3 ;Any data in chan ? BEQ 30$ ; BIC #160000,@R3 ;Clear CH# bits MOV R2,R5 ; MOV #12.,R4 ; 25$: ASL R5 DEC R4 ; BNE 25$ ; BIS R5,@R3 ;'OR' CH# into wd. MOV @R3,(R1)+ ;move ch wd. to outblk INC OBWD ; INC OBWD ; 30$: INC R3 ; INC R3 ; INC R2 ; CMP TOTCHNS,R2 ;All chns done ? BNE 24$ ; RTS PC ; ; ; ; ; ************************* ; * FLASH CODE ON DISPLAY * ; ************************* ; ; ON ENTRY R1=Binary number for display ; (either LBN or ERR or RUN) ; FLASH: CLR R0 ; BIT #LRUN,LEDFLG ;A run led flash ? BEQ FL1 ; MOV RUNMASK,BIN2 ; MOV RUNMASK,DIGOUT ; CALLS DOUT,<0,BIN2,DSTAT,DIGOUT> ; BIC #100000,DIGOUT ; CALLS DOUT,<0,BIN2,DSTAT,DIGOUT> ;Pulse the run light JMP FL3 ;bye ! FL1: BIT #LRSET,LEDFLG ;Display reset ? BEQ FL2 ; CLR BIN2 ;Yes - clear work area BIT #LERR,LEDFLG ;Clear error ? BEQ 20$ ; BIS ERMASK,BIN2 ;Yes - .and. mask bits 20$: BIT #LLBN,LEDFLG ;Clear lbn ? BEQ 30$ ; BIS LBNMASK,BIN2 ;Yes - .and. mask bits 30$: MOV #177777,DIGOUT ; CALLS DOUT,<0,BIN2,DSTAT,DIGOUT> ;Clear display JMP FL3 ;Bye ! FL2: JSR PC,BCD ;Convert R1 to BCD value MOV ERMASK,BIN2 ; BIT #LERR,LEDFLG ; BNE 50$ ; MOV LBNMASK,BIN2 ; 50$: MOV R1,DIGOUT ; CALLS DOUT,<0,BIN2,DSTAT,DIGOUT> ;Output new display FL3: BIC #LRUN!LRSET!LERR!LLBN,LEDFLG ; RTS PC ; ; ; ; ************************** ; * BCD CONVERSION ROUTINE * ; ************************** ; ; ON ENTRY R1=Binary number for conversion ; ; ON EXIT R1=BCD converted value ; BCD: CLR DECBUF ; CLR DECBUF+2 ; CLR DECBUF+4 ; CLR BIN3 ; CLR BIN3 ; CLR BIN2 ; MOV #DECBUF,R0 ; MOV #1,R2 ; CALL $CBDMG ;convert binary # to decimal BIC #LFDIG,LEDFLG ; MOV #DECBUF+4,R5 ;MSD for ERR display MOV #11.,R4 ;BCDoffset for err display BIT #LLBN,LEDFLG ;LBN display ? BEQ 10$ ; BIS #LFDIG,LEDFLG ; MOV #DECBUF+2,R5 ;MSD for LBN disply MOV #8.,R4 ;BCD offset for LBN 10$: MOV #BIN1,R0 ; MOVB (R5)+,@R0 ;put decimal digit in work bin CALL $CDTB ;convert a digit to binary TST R1 ;Zero ? BNE 30$ ; BIT #LFDIG,LEDFLG ;A leading zero ? BEQ 40$ ; MOV #17,R1 ;Yes blank it BR 40$ ; 30$: BIC #LFDIG,LEDFLG ; 40$: MOV R4,R3 ; 20$: BEQ 50$ ; ASL R1 ;shift result to bcd position DEC R3 ; BR 20$ ; 50$: BIS R1,BIN2 ;OR bcd digit into final word SUB #4,R4 ; CMP R5,#DECBUF+6 ; BNE 10$ ; BIT #LLBN,LEDFLG ; BEQ 60$ ; BIT #LRSET,LEDFLG ; BNE 60$ ; CMP #7777,BIN2 ;ALL blank lbn ? BNE 60$ ; BIC #17,BIN2 ;Yes - make it 0 60$: MOV BIN2,R1 ;final result RTS PC ; .EVEN ; ; ; ; ************************************ ; * subroutine DATIM * ; ************************************ ; ; ; On Exit CC = set if error ; DATIM: MOV #FILL,R2 ; MOV #DANS,R3 ; 5$: MOVB (R2)+,(R3)+ ; BNE 5$ ; QIOW$S #IO.WLB,#5,#1,,,,<#DATM,#45.> QIOW$S #IO.RLB,#5,#1,,#IST,,<#DANS,#20.> QIOW$S #IO.WLB,#5,#1,,,,<#DATM,#2> TST IST+2 ;'CR' = dont set date BNE 10$ ; JMP DARETN ; 10$: MOV #DANS,R0 ; MOV R0,R1 ; MOV #20.,R2 ; 20$: CMPB (R1),#': ;Time first ? BEQ TIME ; CMPB (R1)+,#'- ;Date first ? BEQ DATE ; DEC R2 ; BNE 20$ ; JMP DATERR ; DATE: CALL $CDTB ; MOV R1,DABLK+4 ;Set day CMPB R2,#'- ; BNE DATERR ; MOV #MNTH,R1 ; MOV #3,R2 ; CALL $CVTUC ;Convert month to UC CMPB (R0)+,#'- ; BNE DATERR ; MOV #1,R1 ;Find mnth # MOV #MNTAB,R2 ; 10$: MOV #MNTH,R3 ; CMPB (R2)+,(R3)+ ; BEQ 40$ ; ADD #2,R2 ; BR 20$ ; 40$: CMPB (R2)+,(R3)+ ; BEQ 50$ ; INC R2 ; BR 20$ ; 50$: CMPB (R2)+,(R3)+ ; BEQ 30$ ; 20$: CMP #12.,R1 ; BEQ DATERR ; INC R1 ; BR 10$ ; 30$: MOV R1,DABLK+2 ;Set month CALL $CDTB ; MOV R1,DABLK ;Set year CMPB R2,#'* ;End ? BEQ SETDAT ; BR TIME ; DATERR: QIOW$S #IO.WLB,#5,#1,,,,<#DERR,#16.> SEC ; JMP DARETN ; TIME: CALL $CDTB ; MOV R1,DABLK+6 ;Set hrs CMPB R2,#': ; BNE DATERR ; CALL $CDTB ; MOV R1,DABLK+10 ;Set mins CMPB R2,#': ; BEQ 10$ ; 20$: CMPB R2,#'* ;Are secs there ? BEQ SETDAT ; BR DATE ; 10$: CALL $CDTB ; MOV R1,DABLK+12 ; BR 20$ ; SETDAT: STIM$S #DABLK ;Do it CMP #IS.SUC,$DSW ; BNE DATERR ; DARETN: RTS PC ; ; ; ; ******************************* ; * Subroutine TIMC * ; ******************************* ; ; TIMC sorts out hrs:mins ASCII and converts it into ; a single integer number. ; ; On entry R0 = ASCII string ; On exit R1 = integer result (hrs X mins) ; TIMC: CALL $CDTB ;Get start hrs CMP R2,#': ; BNE 10$ ; CMP R1,#25. ; BPL 10$ ; MOV R1,BIN1 ;Hold start hrs CALL $CDTB ;Get mins CMP R1,#60. ; BMI 20$ 10$: QIO$S #IO.WLB,#5,#1,,,#30$,<#DERR,#16.> JMP TERTN ; 30$: SEC ; JMP TIMR ; 20$: MOV BIN1,R0 ;Get hrs MOV R1,BIN1 ;Save mins MOV #60.,R1 ; CALL $MUL ;Convert hrs to mins ADD BIN1,R1 ;Calculate total minutes CLC ; TIMR: RTS PC ; ; ; **************************** ; * subroutine TSTIME * ; **************************** ; ; R0 and R1 are preserved ; On Entry R0=channel word counter ; R1=channel byte counter ; TSTIME: CMPB CHAMAP(R1),#'T ;Time based collection ? BNE 20$ ;No - I'm finished MOV R0,BIN1 ; MOV R1,BIN2 ; MOV DATBUF+G.TIHR,R0 ;Get current hrs MOV #60.,R1 ; CALL $MUL ;Convert to mins ADD DATBUF+G.TIMI,R1 ;Accumulate total mins to now MOV BIN2,R5 ; ASL R5 ; CMP R1,TSMAP(R5) ;Reached start time yet ? BMI 10$ ; CMP R1,TEMAP(R5) ;Yes - past finish up time ? BPL 10$ ; MOV BIN1,R0 ;No - collect data MOV BIN2,R1 ; SEC ; BR 30$ ; 10$: MOV BIN1,R0 ; MOV BIN2,R1 ; 20$: CLC ; 30$: RTS PC ; ; ; ; ****************************** ; * Subroutine PUTIM * ; ****************************** ; ; This routine saves the ASCII form of start and end times ; in relevant buffers. For use by the LC command. ; ; On entry R3 = address(TE or TS)BUF ; R5 = Channel number ; PUTIM: MOV #5,R0 ; MOV R5,R1 ;Channel # CALL $MUL ;Caluculate offset MOV #5,R0 ; ADD R3,R1 ; MOV R1,R3 ; 10$: MOVB #' ,(R1)+ ;Blank the ascii field DEC R0 ; BNE 10$ ; MOV #CMD,R0 ;Get time value CLR R1 ; 20$: MOVB (R0)+,(R3)+ ;Move time to save buffer INC R1 ; CMP R1,TSTAT+2 ;At end yet ? BNE 20$ ; RTS PC ; ; ; ; ************************************ ; * subroutine DSPLAY * ; ************************************ ; ; ; Gets last channel data from memory buffer and formats it ; into DCBUF for printing. ; ; DSPLAY: MOV #27.,R3 ; MOV #DCBUF,R2 ; MOVB #15,(R2)+ ; MOVB #' ,(R2)+ ; 10$: MOV #" ,(R2)+ ;Blank print buffer DEC R3 ; BNE 10$ ; CMP #6,OBWD ;Data in buffer yet ? BEQ 50$ ; MOV OBCUR,R5 ;Get last channel addr ADD OBWD,R5 ; 30$: MOV -(R5),R0 ;Get a channel BMI 50$ ; MOV R5,BIN2 ; MOV R0,R4 ; BIC #70000,R0 ;Mask for channel data MOV #2048.,R1 ; CMP R0,R1 ; BPL 35$ ; SUB R0,R1 ; BIS #NEG,DFLG ; MOV R1,R0 ; BR 20$ ; 35$: SUB R1,R0 ;CH-2048. 20$: MOV ARANGE,R1 ; CALL $MUL ;*Range MOV R1,R2 ; MOV R0,R1 ; MOV #2048.,R0 ; BIT #BYTEN,DFLG ; BEQ 25$ ; MOV #205.,R0 ; 25$: CALL $DDIV ;(/2048.)*10 BIT #NEG,DFLG ; BEQ 60$ ; COM R2 ;Complement -ve value INC R2 ; BIC #NEG,DFLG ; 60$: MOV R2,BIN1 ;Save result BIC #7777,R4 ;Mask for chan num. MOV #12.,R0 ; 40$: ASR R4 ;Shift to lsd DEC R0 ; BNE 40$ ; MOV R4,R0 ; MOV #7.,R1 ; CALL $MUL ;Get buffer offset MOV R1,R0 ; ADD #DCBUF,R0 ; INC R0 MOV BIN1,R1 ;Get channel value (mv) CLR R2 ; CALL $CBDSG ; -> ASCII MOV BIN2,R5 ; JMP 30$ ; 50$: RTS PC ; ; ; ; ****************************** ; * subroutine CHEKT * ; ****************************** ; ; CHEKT checks that a tape just read has the PYRO process ; name on it. If not it sets the C bit before exiting. ; ; CHEKT: MOV #TUBLK,R1 ; ADD #6,R1 ; MOV R1,R0 ; MOV #10.,R2 ; CALL $CVTUC ;Convert name to UC CMP TUBLK+6,#"PY ; BNE 50$ ; CMP TUBLK+10,#"RO ; BEQ 40$ ; 50$: BIS #LERR,LEDFLG ;Wrong name CLR R1 ; JSR PC,FLASH ;***** ERR = 0 ***** SEC ; RTS PC ; 40$: CLC ; RTS PC ; ; ; ; ; ; Parameter Blocks ; .EVEN ARANGE: .WORD 0 BIN1: .ASCII /**/ BIN2: .WORD 0 BIN3: .WORD 0 BSZ: .WORD 128. BUF1: .BLKW 128. BUF2: .BLKW 128. BUFLST: .WORD BUF1,BUF2 CASNUM: .WORD 0 CHAMAP: .BYTE 'O,'O,'O,'O,'O,'O,'O,'O ;S=sun T=time collect, C=continuous ;L=sun LIGHT channel CMD: .BLKB 10. CURRB: .WORD 0 DABLK: .WORD -1,-1,-1,-1,-1,-1,-1,-1 DANS: .BLKB 22. DATBUF: .BLKW 8. DBUF: .BLKW 40. DBUFNO: .WORD 0 DCBUF: .BLKB 58. DECBUF: .BLKW 3 DFLG: .WORD 0 DIGOUT: .WORD 0 DOP: .WORD 1 DPRSET: .WORD -32760. ;Digital scan in 0.3 secs DROUT: .WORD RELOAD,CASIN,RESET DSTAT: .WORD 0 DWD1: .WORD 0 DWD2: .WORD 0 ERMASK: .WORD 74000 FILL: .ASCII /*********************/<0> .EVEN GRPS: .WORD 0 IBUF: .BLKW 40. IBUFNO: .WORD 0 IPRSET: .WORD 163626 ;See comment below on iprset IST: .WORD 0,0 LASTD: .WORD 1 LBN: .WORD 1 LBNMASK:.WORD 3777 LCL: .WORD 0 LEDFLG: .WORD 0 MAPWD: .WORD 0 MCR: .RAD50 /MCR.../ MNTAB: .ASCII /JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC/ .EVEN MNTH: .BLKW 2 NCHNS: .WORD 0 OBCUR: .WORD OBUF1 OBFR: .WORD 0,OBUF2 ;free oublks OBUF1: .BLKW 256. OBUF2: .BLKW 256. OBUSD: .WORD OBUF1,0 ;"in-use" oblks OBWD: .WORD 0 PRMT: .ASCII /PYRO> / RUNMASK:.WORD 100000 SUNC: .WORD 0 TEBUF: .BLKB 40. TEMAP: .WORD 0,0,0,0,0,0,0,0 TEMP: .WORD 0 TIM: .WORD 0 TOTCHNS:.WORD 8. TSBUF: .BLKB 40. TSMAP: .WORD 0,0,0,0,0,0,0,0 TSTAT: .WORD 0,0 TUBLK: .BLKB 20. TUBUF: .WORD 0 TUSTAT: .WORD 0,0 WORK: .BLKW 9. ;0=time,1-8=data DATM: .ASCII <15><12>/Enter Date and Time (dd-mmm-yy hh:mm:ss) ->/ .EVEN TENM: .ASCII /x 10/ DCHED: .ASCII <12><12><15>/ ***** VALUES IN MV *****/ .ASCII <12><15>/CH0 CH1 CH2 CH3 CH4 CH5 CH6 CH7 / .ASCII <12><15> INVAL: .ASCII <12><15>/Invalid Command/<12><15> TVERR: .ASCII <12><15>/Time Value Error/<12><15> CHERR: .ASCII <12><15>/Channel # Error/<12><15> LCBUF: .ASCII <12><15>/CHAN TYPE/ .ASCII <12><15>/ / TBUF: .ASCII / / OPMES: .ASCII <12><15>"Enter O/T/S/C/L for channel ->" TSTRT: .ASCII <12><15>/Enter Start Time (hh:mm) ->/ TEND: .ASCII <12><15>/Enter End Time (hh:mm) ->/ DERR: .ASCII <15><12>/Syntax Error/<12><15> .EVEN ; ; ; ; SETTING IPRSET ; ; IPRSET=2'S complement ( clockrate X desired time / #interrupts) ; ; where: desired time = time in secs to enter AST service routine. ; #interrupts = BSZ / #chans (128/8) ; ; in this program IPRSET = 2's Comp (10,000 X 10 / 16) = 163626(octal) ; ; .END START