X-Git-Url: http://gitweb.hachti.de/?a=blobdiff_plain;f=sw%2Frescue%2Flab8e_goettingen%2Fdisk2_11%2Frka%2Fparoff%2Fadbuff.ra;fp=sw%2Frescue%2Flab8e_goettingen%2Fdisk2_11%2Frka%2Fparoff%2Fadbuff.ra;h=97aaffba10b39b0525dc836c8e4a1599e3592ff6;hb=81e70d488b71bf995c459ca3a02c025993460ffa;hp=0000000000000000000000000000000000000000;hpb=07ec0278333ed187ac242dedcff13c56cf1b0b91;p=pdp8.git diff --git a/sw/rescue/lab8e_goettingen/disk2_11/rka/paroff/adbuff.ra b/sw/rescue/lab8e_goettingen/disk2_11/rka/paroff/adbuff.ra new file mode 100644 index 0000000..97aaffb --- /dev/null +++ b/sw/rescue/lab8e_goettingen/disk2_11/rka/paroff/adbuff.ra @@ -0,0 +1,975 @@ +/ OS/8 TSAR/TSARINA +/ +/ ADBUFF.RA +/ +/ DEC-S8-STSAA-A-LA25 +/ +/ K. ELLSON AND L. PEARSON +/ +/ /8 AD CONVERSION CLOCKED WITH CLOCK ROUTINE +/ /8 /1 AD CONVERSION CLOCKED WITH CLOCK1 ROUTINE +/ /8/4/1 AD CONVERSION CLOCKED WITH CLOCK1 AND SCHMITT TRIGGER INPUT TIMED WITH CLOCK ROUTINE +/ +/ +/ TSAR SUBROUTINE - BUFFERED A/D +/ COPYRIGHT 1973 +/ DIGITAL EQUIPMENT CORPORATION +/ MAYNARD, MASSACHUSETTS 01754 +/ +/ THIS PACKAGE PROVIDES A FUNCTIONAL REPLACEMENT FOR +/ THE FOLLOWING FORTRAN IV LIBRARY SUBROUTINES: REALTM +/ AND ADB. REALTM AND ADB ARE REPLACED BY THE SUBROUTINE +/ THRUPT. A THRUPT CALL IS ILLUSTRATED BY THE FOLLOWING +/ FORTRAN PROGRAM. +/ +/************************************************************* +/ +/ EXTERNAL STAT1,STAT2 +/ INTEGER BUFF1(85),BUFF2(85),IPARMS(3),HASH(# OF CHANNELS) +/ CALL THRUPT(BUFF1,BUFF2,IPARMS,HASH,NTRIG) +/ CALL CLOCK(8,IRATE) @ IF NO /1 SWITCH AT ASSEMBLY TIME +/ @ FOR A/D CONVERSION TIMED WITH FIRST DK8-EP +/ CALL CLOCK1(8,IRATE) @ IF /1 SWITCH SET AT ASSEMBLY TIME +/ @ THIS IS FOR A/D CONVERSION TIMED WITH 2ND DK8-EP +/ IF YOU USE BOTH CLOCKS ON ONE SYSTEM, THEN YOU +/ MAY SWITCH ON ONLY ONE CLOCK-TIMED A/D CONVERSION. +/ THIS MEANS: ONLY ONE CLOCK MAY BE STARTED WITH FUNCTION=8 (BIT 9 SET) +/ ... +/ 100 IF (STAT1-0.5) 100, 110, 999 +/ 110 WRITE (5) BUFF1 +/ CALL RELEAS (1) +/ ... +/ 999 WRITE (4,1000) +/ 1000 FORMAT (' SAMPLING TOO FAST') +/ CALL CLOCK (0,0) +/ ... +/ +/************************************************************ +/ +/ BUFF1 - ONE OF 2 BUFFERS FOR THE ANALOG DATA, 255 12 BIT +/ WORDS ARE STORED IN EACH BUFFER +/ +/ STAT1 - DYNAMIC STATUS WORD OF BUFF1. THE VALUES 0.25, +/ 0.5, AND +1. INDICATE THAT THE BUFFER IS NOT FILLED, +/ BUFFER IS FILLED, AND BUFFER OVERFLOW. +/ +/ BUFF2 - THE SECOND BUFFER. +/ +/ STAT2 - THE DYNAMIC STATUS WORD OF BUFF2, VALUES ARE THE +/ SAME AS FOR STAT1. + / +/ IPARMS - THE PARAMETER VECTOR WHICH CONTAINS IN ORDER THE +/ STARTING CHANNEL, THE NUMBER OF CHANNELS, AND THE NUMBER +/ OF SAMPLES. +/ HASH - OPTIONAL: A TABLE CONTAINING THE READ VALID INFORMATION FOR A/D CHANNELS AND STRIGG INPUTS +/ NTRIG - OPTIONAL BUT HASH MUST BE SPECIFIED: +/ THE NUMBER OF SCHMITT TRIGGER CHANNELS TO SAMPLE +/ CONFIGURATION REQUIRED FOR A/D AND STRIGG SAMPLING: +/ FIRST DK8-EP: FREE RUNNING TIMER (10 KHZ OR 100 KHZ) FOR TRIGGER INPUT. +/ CALL CLOCK4 (1 TO 7,3) FOR 10 KHZ +/ CALL CLOCK4 (1 TO 7,30) FOR 100 KHZ +/ SECOND DK8-EP STARTS THE A/D VIA EXTERNAL EVENT: CALL CLOCK1(8,RATE) +/ TIME WORD: THE INTERVALL BETWEEN TWO A/D CYCLES IS DIVIDED INTO +/ 12 SLICES CALLED S0 TO S11. +/ AN EXTERNAL EVENT BETWEEN 0 AND S0 (SAMRAT/12) SETS THE LEFTMOST BIT 0. +/ ' '' '' '' S11 AND SAMRAT SETS THE RIGHTMOST BIT 11. +/ +/ UPDATES: +/ +/ WGET: THE THIRD PARAMETER (RESULT) IS OPTIONAL +/ VALID CALLS: +/ I=WGET(BUFF,PNTR,RESULT) +/ I=WGET(BUFF,PNTR) +/ CALL WGET (BUFF,PNTR,RESULT) +/ +/ 11-SEP-80 HA +/ +/ INTERRUPT SERVICE ROUTINE FSMPLE: +/ BEFORE THE READ ADRB WAIT FOR ADSE TO AVOID A NON VALID READ +/ IF CLOCK DID'NT START THE AD CONVERTER. +/ THEREFORE IN ANY CASE (ONE OR MORE CHANNELS) THE +/ CLOCK MUST BE STARTED WITH CALL CLOCK(8,FREQU). +/ FIRST PARAMETER OF CLOCK MUST BE 8 ! +/ 29-SEP-80 HA +/ 1-OCT-82 HA REV 2.0 PACKS THE SAMPLE +/ 15-JUL-83 HA REV 2.1 REARANGES CODE FOR PDP12 LINC OPTION +/ 18-MAR-85 HA REV 3.0 ALLOWS TWO DK8-EP MODULES +/ FOR A/D TRIGGED WITH DEV. CODE 13 CLOCK: /8 SWITCH +/ FOR A/D TRIGG'D WITH DEV. CODE 17 CLOCK: /1 /8 SWITCH +/ FOR A/D ON PDP-12 : NO SWITCH +/ +/ 26-JUN-85 HA REV 3.1 ALLOWS SCMITT TRIGGER INPUT WITH DK8-EP DEV 13 AND CLOCKED A/D WITH DK8-EP DEV 17 +/ 12-JUL-85 HA REV 4.0 EVERYTHING CONFUSED +/ 20-AUG-85 HA REV 4.1 REMOVES BUG IN TRIGG. TIME PICKUP ROUTINE +/ + / + CL1DEV=13*10 / FIRST DK8-EP + CL2DEV=17*10 / SECOND DK8-EP +/ + MQL=7421 + MQA=7501 / WE USE EAE MODE B + ACL=7701 + SWP=7521 + CAM=7621 + SWAB=7431 + DAD=7443 + DST=7445 + DLD=DAD!CAM + DDZ=DST!CAM + DVI=7407 + DPIC=7573 + DPSZ=7451 + IFNSW 1 < + EXTERN #CLINT +CLINT= #CLINT + IFSW 4 < BAD SWITCH /1/4 > + > + IFSW 1 < + EXTERN #CLIN1 +CLINT= #CLIN1 + EXTERN #CLINT + > + CSTAT=157 /CLOCK ROUTINE PUTS CLSA BITS IN HERE + ENTRY STAT1 /ALLOW FORTRAN ACCESS TO THES + ENTRY STAT2 /LOCATIONS + COMMZ #PAGE0 + ORG 2 +PBUFF, 0 /PNTR TO CURRENT BUFFER +CURSTT, 0 /PNTR TO CURRENT STATUS WORD +NXTSTT, 0 /PNTR TO NEXT STATUS WORD +CURBUF, 0;0 /START OF CURRENT BUFFER PNTR +NXTBUF, 0;0 /START OF NEXT BUFFER PNTR + /STATUS WORDS, VALUES +STAT1, F 0.25 /0.25, 0.5, & 1.0 INDICATE +STAT2, F 0.25 /STATUS WORD IS NOT FILLED, + /FILLED, AND OVERFLOWED +/STATUS WORD: F 0.25 = 7777;2000;0000 NOT FILLED +/ F 0.5 = 0000;2000;0000 FILLED +/ F 1.0 = 0001;2000;0000 OVERFLOWED +/ + IFSW 8 < + ADSK=6534 + ADRB=6533 + ADST=6532 + ADLM=6531 + ADLE=6536 + ADCL=6530 + ADRS=6537 + ADSE=6535 + CLED=6134 + CLAB=6003 + CLBA=6006 / DO NOT FORGET TO INSERT THE DEVICE CODE + CLZE=6000 + > + IFNSW 8 < + ESF=4 + LINC=6141 + PDP=2 + SAM=100 + CLEN=6134 + > + + + FIELD1 FSMPLE + 0 /INTERRUPT TIME A/D SAMPLER + ADDR MQAC /SAVE AC AND MQ --> MQAC + ORG .-2; DST; ORG .+1 + ADDR CLKOVR / CLEAR OVERFLOW COUNTER FOR THE SCHMITT TRIGGER SERVICE ROUTINE + ORG .-2; DDZ; ORG .+1 + IFSW 4 < / IF TRIGGER INPUT THEN WE CLEAR THE CLOCK COUNTER + CLAB CL1DEV + > + IFNSW 4 < NOP > / HERE TO INSERT A WORD TO GET THE SAME WORD COUNT FOR BOTH PROGRAM VERSIONS + TAD NCHANL+2 /NUMBER OF CHANNELS + DCA NCHANL+1 /INTO COUNTER + JMS% ITSTVL+1 /TEST VALID FOR THE FIRST SAMPLE + JMS INVALID /AND DECLARE NOT VALID +WAITSP, + IFNSW 8< + JMS LNCSAM /INITIATE SAMPLE +NEXTCH, ISZ SAMINS /UPDATE SAM INST FOR NXT CHAN + JMS LNCSAM + TAD SAMTMP + > + IFSW 8 < + ADSK / WAIT FOR COMPLETION OF CONVERSION + JMP .-1 + ADRB /READ SAMPLE + JMS PUTSAM / INSERT INTO THE OUTPUT BUFFER AND TEST IF WORK DONE + JMP MORESM / SKIP TO MORESM +/ +/ +SKIPSM,/ SKIP ONE A/D SAMPLE + JMS UPDCNT / INCREMENT THE TOTAL SAMPLE COUNTER (ALL CHNLS+STRIGS)*SAMRAT + ADRS / LOAD MUX REGISTER --> AC + IAC / AND INCREMENT- WE SKIPP THIS CHANNELS + ADLM / BUMP BACK INTO THE A/D MUX REGISTER +/ +MORESM,/ + ISZ NCHANL+1 / ANY MORE CHANNELS TO SAMPLE? + SKP / START THE NEXT CONVERSION IF THERE IS ANY REMAINING + JMP NOTMOR / NOTHING MORE TO A/D SAMPLE + JMS% ITSTVL+1 /HERE ONLY IF SOME MORE A/D TO SAMPLE! + JMP SKIPSM / SKIP THE NEXT SAMPLE, RETURNS TO MORESM !! + ADST / AND START THE NEXT CONVERSION - AUTO INCREMENT MODE! + > + JMS INCPTR / INCREMENT BUFFER POINTER + JMP WAITSP / AND TAKE THE NEXT SAMPLE +NOTMOR,/ + TAD CSTART+2 /STARTING CHANNEL + IFSW 8 < + ADLM / ELSE RESET MUX REGISTER + > + IFNSW 8 < + DCA SAMINS + JMS LNCSAM /SET CHANNEL TO START IN CASE + /CLOCK INITIATED + > +/ +/ HERE WE INSERT THE STRIGG TIME WORDS +/ + CLA + TAD IWSTRI+1 /HOLDS ADDR + DCA IWSTRI / HOLDS POINTER TO THE TIME WORD + TAD WSTRC / -(NUMBER OF TRIGG INPUTS+1) --> AC + DCA IWSTRC / HOLDS THE COUNTER +IWLOP1, + JMS INCPTR / INCREMENT BUFFER POINTER + ISZ IWSTRC / IF ANY MORE TRIGG INPUTS + SKP / THEN SKIP + JMP IWLOP2 / ELSE RESET AC AND MQ AT IWLOP2 + JMS% ITSTVL+1 /TEST FOR VALID SAMPLE (INVALID MEANS CRAZY PROGRAMMER!) + JMS INVALID / SET THE INVALID FLAG + TAD% IWSTRI / TRIGG TIME WORD --> AC + JMS PUTSAM /INSERT TIME WORD INTO THE OUTPUT BUFFER, CLEARS AC + DCA% IWSTRI / CLEAR THE TIME WORDS + ISZ IWSTRI / INCREMENT POINTER TO THE TIME WORDS + JMP IWLOP1 / AND LOOK FOR THE NEXT TRIGG WORDS TO PROCESS +IWLOP2, + ADDR MQAC /RESTORE AC AND MQ + ORG .-2; DLD; ORG .+1 + JMP% FSMPLE /DONE FOR THIS TIC + / +/ SAMPLING FINISHED +/ +SAMDON,/ + JMS INCPTR / INCREMENT BUFFER POINTER + CLA / CLEAR THE STATUS WORD + DCAZ% CURSTT /SET STATUS OF CURRENT FULL +SAMXIT,/ STOP THE SAMPLING, DISABLE CLOCK INTERRUPT + ADDR CLINT + ORG .-2; DDZ; ORG .+1 + IFSW 4 < + ADDR #CLINT + ORG .-2; DDZ; ORG .+1 > / DISABLE CLOCK EXTENSION ROUTINE + ADDR MQAC /RESTORE AC AND MQ + ORG .-2; DLD; ORG .+1 + JMP% FSMPLE +/ +/ +/ HERE WE COUNT THE WHOLE NUMBER OF SAMPLES TOKEN +/ +UPDCNT, 0 + ADDR NPOINT+1 / NPOINT IS A 3 WORD FPP BASE PAGE VARIABLE, TAKE CARE + ORG .-2; DLD; ORG .+1 + DPIC / INCREMENT DOUBLE PREC. COUNTER TO TEST FOR MORE SAMPLES + ADDR NPOINT+1 / BUMP INTO COUNTER + ORG .-2; DST; ORG .+1 + DPSZ / SKIP IF WORK DONE + JMP% UPDCNT + JMP SAMDON / SET STATUS OF CURRENT BUFFER FULL: SAMPLE DONE +/ +/ +PUTSAM, 0 / INSERTS AC INTO OUTPUT BUFFER, ON RETURNS CLEARS AC! + ISZ AVALID / VALID INPUT? + SKP / AVALID IS SET TO -1 FOR INVALID SAMPLE, SO SKIP + JMP PUTSA1 / NON VALID, RETURN WITHOUT ACTION +BUFCDF, HLT /REPLACED BY CDF TO BUFFER + DCAZ% PBUFF + CDF 10 / USED FOR POINTER PVALID! + CLA CMA / -1 --> AC + DCA PUTFLG / DON'T FORGET TO INCREMENT THE BUFFER POINTER -1 --> PUTFLG + DCA AVALID / CLEAR VALID FLAG FOR NEXT CALL +PUTSA1,/ + JMS UPDCNT / UPDATE THE TOTAL SAMPLE COUNT + CLA / CLEAR AC FOR RETURN + JMP% PUTSAM +/ +/ +INVALID,0 / SET THE ACTUAL SAMPLE INVALID + CLA CMA / -1 --> AC + DCA AVALID + JMP% INVALID / ON RETURN AC=0 +PUTFLG, 0 / SET TO -1 IF WE HAVE TO INCREMENT THE BUFFER POINTER + +AVALID, / / ACTUAL VALID FLAG +ITSTVL, ADDR TSTVLD / TEST FOR VALID READ +IWSTRC, 0 / NEGATIVE NUMBER OF STRIGS EVENT CHANNELS -1 (FOR COUNTER) +WSTRC, 0 / -(NUMBER OF STRIG INPUTS+1) PLACED HERE BY THRUPT +IWSTRI, ADDR TIMWRD / POINTER TO THESE TIME WORDS +NCHANL, 0;0;0 +SAMCNT, +CSTART, 0;0;0 + / +L10, 10 +/ +INCPTR, 0 + CLA / CLEAR AC + ISZ PUTFLG / IF WE HAVE TO INCREMENT THE BUFFER POINTER, + JMP% INCPTR / THEN SKIP ELSE RETURN + ISZZ PBUFF /ELSE INCR PNTR & SKIP IF WE + JMP FLDOK /CROSSED A FIELD BOUNDARY + TAD BUFCDF /UPDATE FIELD + TAD L10 + DCA BUFCDF +FLDOK, + ISZ SAMCNT /INCR BUFFER CNTR & SKIP IF + JMP% INCPTR /FILLED. BUFFER OK + DCAZ% CURSTT /SET STATUS WORD TO 0.5 + /FOR BUFFER FILLED + TADZ NXTSTT /SWAP STATUS WORD PNTRS + DCA TMP / NXTSTT<=> CURSTT + TADZ CURSTT + DCAZ NXTSTT + TAD TMP + DCAZ CURSTT + TADZ% CURSTT /HAS USER RELEASED THIS BUFFER + SMA CLA + JMP% ITOOFST+1 /NO, SAMPLING TOO FAST! + JMS% ISWPBFR+1 / SWAP BUFFER + JMP% INCPTR / BUFFER POINTER UPDATED +ISWPBF, ADDR SWPBFR +/ +/ +TMP, +ITOOFS, ADDR TOOFST +/ + ORG FSMPLE+200 +/ +/ HERE WE SWAP THE INPUT BUFFERS POINTERS +/ +SWPBFR, 0 +/ +/ SWAP BUFFER POINTERS +/ + TADZ NXTBUF / NXTBUF <=> CURBUF + DCA% IBUFCDF / BUFCDF, PBUFF = NXTBUF + TADZ NXTBUF+1 + DCAZ PBUFF + TADZ CURBUF + DCAZ NXTBUF + TADZ CURBUF+1 + DCAZ NXTBUF+1 + TAD% IBUFCDF + DCAZ CURBUF + TADZ PBUFF + DCAZ CURBUF+1 + TAD% IBUFSIZ /RESET BUFFER COUNTER + DCA% ISAMCNT + JMP% SWPBFR +IBUFCDF=.+1 + ADDR BUFCDF +IBUFSIZ=.+1 + ADDR BUFSIZ +ISAMCNT=.+1 + ADDR SAMCNT +/ +/ SAMPLING RATE TOO FAST +/ +TOOFST,/ + CLA IAC /SET STATUS WORD TO 1.0 + DCAZ% CURSTT + IAC + DCAZ% NXTSTT + JMP% ISAMXIT+1 / DISABLES CLOCK INTERRUPTS +ISAMXIT,/ + ADDR SAMXIT + IFNSW 8 < +LNCSAM, 0 /LINC SAM SUBROUTINE + LINC +SAMINS, SAM 0 /SAMPLE AND SELECT NEXT CHANNEL + PDP + DCA SAMTMP /SAVE IT + JMP% LNCSAM + > + / +/ INTERRUPT TIME SCHMITT TRIGGER INPUT HANDLER +/ +FIREED, 0 / ON ENTRY AC IS CLEARED BY CLOCK RTN + CLA CLL CMA RTL / -3 --> AC + ADDR MQSAVE / SECOND: STRIG COUNTER, FIRST: SAVES MQ + ORG .-2; DST; ORG .+1 + CLA + TADZ CSTAT / LOOK AHEAD FOR CLOCK OVERFLOW + RAL CLL / LINKS GOES ON HERE IF CLOCK OVERFLOWED + SNA CLA / AND IF THERE IS NO STRIGG THEN JUMP TO CLOCK OVERFLOW HANDLING + JMP CLKINT +/ + CAM / MQ HOLDS # OF STRIGG FIRED, FIRST IS #0 + TADZ CSTAT / CLSA BITS OF FIRST CLOCK --> AC +TRILOP, RAR / STRIG BITS --> LINK + SWP / NOW AC HOLDS # OF STRIGG + SZL / SKIP IF STRIGG DID NOT FIRE + JMS TRIGGD / ELSE SET THE TRIGGER TIME WORD + IAC / INCREMENT FOR NEXT STRIGG + SWP / # OF STRIGG --> MQ, CLSA BIT MASK --> AC + ISZ MQSAVE+1 / SOME MORE STRIGS? + JMP TRILOP / YES, FETCH THE NEXT EVENT + CAM / STRIGS DONE, TEST FOR CLOCK OVERFLOW + TADZ CSTAT / CLSA BITS --> AC + RAL / LINK GOES ON IF CLOCK OVERFLOWED + SZL / IF NO CLOCK OVERFLOW THEN RETURN +CLKINT, ISZ CLKOVR+1 / ELSE INCREMENT THE CLOCK OVERFLOW COUNTER (EAE HIGH ORDER WORD) + NOP / PROTECT ISZ + ADDR MQSAVE / RESTORE MQ, CLEAR AC! TRICKSY! + ORG .-2; DLD; ORG .+1 + CLA + JMP% FIREED / RETURN TO CLOCK ROUTINE +/ +MQSAVE, 0;0 / SECOND WORD IS USED FOR STRIGG COUNTER, FIRST SAVES MQ ON ENTRY +CLKOVR, 0;0 / HERE IS THE CLOCK OVERFLOW COUNTER, (SINGLE PRECISION, SECOND WORD HOLDS CLOCK COUNTER) +/ CLKOVR IS CLEARED AT EACH A/D INTERRUPT. WE ALSO CLEAR THE CLOCK COUNT REGISTER. +/ SINCE A/D CLOCK AS HIGHER INTERRUPT FREQUENCY THAN TRIGG CLOCK +/ THE TRIGGER CLOCK OVERFLOW SHOULD BE ZERO ALL THE TIME! +/ BUT WHAT'S SHURE IN A COMPUTER'S WORLD NOWADAYS???? +/ +MQAC, 0;0 / HERE FSMPLE AND TRIGGED ROUTINE SAVE MQ&AC ON ENTRY +ITIMWR, ADDR TIMWRD / POINTER TO STRIGG TIME WORDS +TIMWRD, 0;0;0 / TIME WORDS FOR 3 SCHMITT TRIGGER CHANNELS +TIMBIT, 0;0 / THRUPT INSERTS CLOCKRATE/SAMRAT/12 +M15, -15 / DEC 13: USED TO TEST TIME SLICE OVERFLOW +IBITWR, TAD BITWRD / POINTER TO LOAD THE CORRECT BIT MASK FOR EACH TIME SLICE + 7777 / TOO MUCH EVENTS +BITWRD, 4000 + 2000 + 1000 + 0400 + 0200 + 0100 + 0040 + 0020 + 0010 + 0004 + 0002 + 0001 + 0001 / HERE FOR SOME VERY LATE EVENTS +/ +/ HERE WE COMPUTE THE STRIGG TIME WORD +/ +TRIGGD, 0 / ON ENTRY AC HOLDS NUMBER OF SCHMITT TRIGGER FIRED + ADDR MQAC / SAVE AC AND MQ + ORG .-2; DST; ORG .+1 + TAD ITIMWR+1 / COMPUTE CORRECT ADDRESS OF TIME WORD + DCA ITIMWR + CLBA!CL1DEV / LOAD CLOCK BUFFER --> AC + MQL / AND INTO MQ, CLEAR AC + ADDR CLKOVR /AND ADD THE CLOCK OVERFLOW COUNTER REQUIRES MODE BITS OF CLOCK SET TO 10 + ORG .-2; DAD; ORG .+1 + ADDR TIMBIT / TIMBIT= RATE*12/SAMRAT HERE WE COMPUTE THE TIME SLICES + ORG .-2 ; DVI ; ORG .+1 + ACL / MQ HOLDS QUOTIENT SO: TIME SLICE -> MQ -> AC + TAD M15 / IF THERE ARE ALLREADY 13 SLICES PASSED + SMA SZA CLA / THEN STOP, ELSE GOON + JMS OVRTRI / STRIGG INPUT OVERFLOWED + ACL / TIME SLICE --> AC + TAD IBITWR / HERE WE DO SOME COMPUTATIONS + DCA .+3 / IN ORDER TO FETCH THE + TAD% ITIMWR / CORRECT BIT AND TIMEWORD. + MQL / PREP FOR .OR. TIMEWORD AND SLICE BIT + TAD BITWRD / IS REPLACED BY CORRECT TAD BITWRD+SLICE + MQA / OR THE TIMEWORD AND THE BIT + DCA% ITIMWR / AND PUSH BACK + ADDR MQAC / RESET AC AND MQ + ORG .-2; DLD; ORG .+1 + JMP% TRIGGD / AND RETURN! +/ +OVRTRI, 0 / HANDLES STRIGG OVERFLOWES + HLT +/ CLA CMA / -1 --> AC + MQL / -1 --> MQ + JMP% OVRTRI / + ORG FSMPLE+400 +ADSETU, 0 /SET UP ROUTINE + SWAB / SWITCH EAE TO MODE B (USED FOR HARD FPP12) + TADZ CURBUF /GET FIELD OF BUFFER + JMS MAKCDF /MAKE 3 BITS FLD INTO CDF + DCAZ CURBUF + TADZ CURBUF + DCA% ABUFCDF+1 /SAVE IN SAMPLER CODE + TADZ CURBUF+1 /SET SAMPLER BUFFER POINTER + DCAZ PBUFF + TADZ NXTBUF /GET FIELD OF ALTERNATE BUFFER + JMS MAKCDF + DCAZ NXTBUF + TAD BUFSIZ /SET INITIAL COUNT + DCA% ASAMCNT+1 + TAD ISTAT1+1 + DCAZ CURSTT / INSERT ADR. OF ACTUAL STATUS WORD + TAD ISTAT2+1 + DCAZ NXTSTT / AND THE ADR. OF NEXT STATUS WORD + ADDR NPOINT+1 / SINCE FPP AND EAE HAVE DIFFERENT HIGH ORDER AND LOW ORDER + ORG .-2; DLD; ORG .+1 / WORD ORDER IN MEMORY + SWP + ADDR NPOINT+1 / WE HAVE TO CHANGE IT + ORG .-2; DST; ORG .+1 + ADDR TIMWRD + ORG .-2; DDZ; ORG .+1 / CLEAR THE STRIGG TIME WORDS + ADDR TIMWRD+1 + ORG .-2; DDZ; ORG .+1 + ADDR CLKOVR / CLEAR CLOCK OVERFLOW COUNTER + ORG .-2; DDZ; ORG .+1 + IFSW 8 < + CLA CMA /STOP THE CLOCK + IFSW 1 < + CLZE CL2DEV + IFSW 4 < + CLZE CL1DEV > > + IFNSW 1 < + CLZE!CL1DEV > + CLA + ADCL /CLEAR AD LOGIC JUST IN CASE + TAD L300 /SET AD ENABLE BITS, EXT START, AUTO INCREMENT + ADLE + TAD% JCSTART+1 /STARTING CHANNEL NUMBER + ADLM + > + IFNSW 8 < + CLEN /STOP THE CLOCK + TAD% JCSTART+1 /SET UP INITIAL SAM INSTRUCTION + TAD L100 + DCA% JCSTART+1 + TAD% JCSTART+1 + DCA SAMINS + TAD L100 /SET FAST SAM BIT + IOF /TURN OFF INTERRUPTS IN LINC MODE + LINC /ENTER LINC MODE + ESF + PDP + JMS LNCSAM + ION + ADDR MQAC / SAVE MQ + ORG .-2; DST; ORG .+1 + ADDR TIMWRD + ORG .-2; DDZ; ORG .+1 + DCA TIMWRD+1 / CLEAR STRIGG TIME WORDS + ADDR CLKOVR / AND CLEAR CLOCK OVERFLOW COUNTER + ORG .-2; DDZ; ORG .+1 + > + CIF CDF + JMP% ADSETU +/ +ISTAT1, ADDR STAT1 +ISTAT2, ADDR STAT2 +JCSTAR, ADDR CSTART+2 +ASAMCN, ADDR SAMCNT +ABUFCD, ADDR BUFCDF + / +/ MAKE THREE BITS OF AC9-11 INTO CDF +/ +/ COMPUTE THE NUMBER OF BITS SET IN THE TRIGGER TIME WORD +/ +CMPBIT, 0 / ON ENTRY BITSCN HOLDS THE WORD TO SCAN + CLA + TAD M14 / 12 BITS TO SCAN, PREP THE COUNTER + DCA BITLCN + DCA BITCNT / CLEAR BIT COUNTER + TAD BITSCN / TRIG TIME WORD --> AC +BITLOP, RAL / SHIFT BIT INTO THE LINK + SZL + ISZ BITCNT + ISZ BITLCN + JMP BITLOP + CDF CIF 0 / HOME TO FPP + JMP% CMPBIT / FROM TRAP4 +/ +BITSCN, 0 / ON ENTRY: HOLDS THE WORD TO SCAN +BITCNT, 0 / ON RETURN: HOLDS NUMBER OF BUTS SET +BITLCN, 0 / LOOP COUNTER, ABOVE TWO LOCATIONS ARE ALSO USED AS INDEX REGS 0 AND 1 +M14, -14 / DEC -12 +/ +/ +MAKCDF, 0 + AND L7 + CLL RTL +BASEX, RAL + TAD CDF0 + JMP% MAKCDF +/ +NPOINT, 0;0;0 +CDF0, CDF + 0;0 +L7, 7 +BUFSIZ, -377 + IFSW 8 < +L300, 300 + > + IFNSW 8 < +L100, 100 + > +/ +TEMP, 0;0;0 + ORG 10*3+BASEX + 0 + JA NAME+3 + 0 +SAMRTN, JA . +FP25, F 0.25 +XVALID, F 114. / LENGTH OF READ VALID VECTOR (MUST BE MULTIPLE OF 3) +VALID, ORG .+162 / AND HERE IS THE BUFFER SPACE +/ +/ ROUTINE TO TEST FOR VALID SAMPLE ( PACKED DATA) +/ +PVALID, ORG .+2 /POINTER TO ACTUAL POSITION INSIDE VALID VECTOR +MVALID, ORG .+2 /VALID VECTOR: LAST ADDRESS USED +NVALID, ADDR VALID-1 /HOLDS ADR. OF FIRST WORD OF VALID VECTOR -1 +/ +TSTVLD, ORG .+1 / JMS TSTVLD + / SAMPLE NON VALID RETURN + / SAMPLE VALID RETURN +/ ON RETURN AC=0 + ISZ PVALID+1 / GET THE NEXT LOC. OF VALID VECTOR + CLA + TAD PVALID+1 + TAD MVALID+1 / IF WE REACHED THE END OF THE VECTOR THEN + SPA CLA / WE RESET TO THE START ELSE + JMP L1 / CONTINUE AT L1 + TAD NVALID+1 + IAC + DCA PVALID+1 +L1, TAD% PVALID+1 / READ VALID FLAG --> AC + SNA CLA / IF THIS READ WAS VALID THEN WE INCREMENT THE BUFFER POINTER ELSE + JMP% TSTVLD / WE TAKE THE NEXT SAMPLE INTO THIS LOCATION + ISZ TSTVLD / TAKE THE NORMAL RETURN FOR VALID SAMPLE + JMP% TSTVLD + EXTERN #ARGER + SECT THRUPT + BASE 0 + STARTD + FLDA 30 /GET RETURN ADDR + FSTA SAMRTN + STARTF + FLDA 0 + FSTA# TRETU + STARTD + FLDA% 0 / COMPUTE THE NUMBER OF PARAMETERS + FSUB 0 + FSUB# TWO + SETX XR0 + LDX 1,X1 + ALN X1 / DIVIDE BY TWO + FNEG + ATX X2 / NEGATIVE NUMBER OF ARGUMENTS --> X2 + FLDA 0 /GET ARG POINTER + BASE BASEX + SETB BASEX + FSTA TEMP /SAVE ARG POINTER + LDX 4700,0 + FCLA + FSTA CLINT /STOP ANY SAMPLING NOW! + LDX 4701,0 + IFSW 4 < + FSTA #CLINT > / DISABLE STRIGG EVENTS + LDX 4702,0 + FLDA% TEMP,1 /GET BUFF1 ADDRESS + FSTA CURBUF + LDX 1,X0 + JXN TH0,X2+ + TRAP4 #ARGER +TH0, + FLDA% TEMP,1+ /GET BUFF2 ADDR + FSTA NXTBUF + LDX 2,X0 + LDX 4703,0 + JXN TH1,X2+ / IF THERE ARE ONLY TWO PARAMETERS THEN + TRAP4 #ARGER / ARGUMENT ERROR # 2 +TH1, + FLDA% TEMP,1+ /ADDR OF PARAMETERS + FSTA PARAM / SAVE ADDR. OF PARAMETERS + STARTF + FCLA + FSTA PACK / CLEAR PACK & NTRIGG IF THERE ARE ONLY 3 PARAMS + FSTA NTRIG / DISABLE TRIGG EVENTS + FSTA TIMRAT + STARTD + JXN TH2,X2+ / IF THERE ARE 4 OR MORE PARAMETERS THEN FETCH THE LAST BUT ONE + JA TH3 / ELSE THERE ARE 3 ARGUMENTS +TH2, FLDA% TEMP,X1+ / ADDR OF FOURTH ARGUMENT --> PACK + FSTA PACK + JXN TH6,X2+ / IF THERE ARE 5 PARAMETERS GOTO TH5 + JA TH3 / ONLY FOUR PARAMETERS +TH6, FLDA% TEMP,X1+ + FSTA NTRIG / ADDR OF STRIG COUNT --> WSTRC + JXN TH10,X2+ / IF THERE ARE 5 PARAMETERS THEN THERE MUST BE A SIXTH ONE + LDX 4,X0 / FIVE PARAMETERS ARE INVALID, ARGUMENT ERR 5 + TRAP4 #ARGER +TH10, FLDA% TEMP,X1+ + FSTA TIMRAT / INSERT RATE/SAMRAT/12 --> TIMBIT +TH3,/ + FLDA PARAM / RESTORE ADR. OF THIRD ARGUMENT + FSTA TEMP + STARTF + LDX 0,1 + FLDA% TEMP,1 /STARTING CHANNEL + ALN 0 + FSTA CSTART + FLDA% TEMP,1+ /# CHANNELS + FSTA CHNLS + FNEG + ALN 0 + FSTA NCHANL + FLDA% TEMP,1+ /NUMBER OF POINTS + FNEG + ALN 0 + FSTA NPOINT + FLDA PACK + JEQ TH4 / ONLY THREE PARAMETERS, CLEAR PCKSIG + FLDA% TEMP,1+ + FNEG + FSUB FL1 + ALN 0 +TH4, FSTA PCKSIG + ATX X2 +/ +TBIN0, SETX VALID / PREPARE THE VALID VECTOR + LDX 1,X0 + SETX XR0 + STARTD + FLDA# NVALID / TAKE CARE, THESE LOCATION ARE IN BASE PAGE! + FSTA# PVALID + FNEG + FADD PCKSIG+1 + FSTA# MVALID +/ + FLDA PACK + JEQ TH5 + FSTA TEMP + LDX -1,X1 / X2 HOLDS PCKSIG ! + + FLDA TBIN0 + FSTA TBIN1 + STARTF +THL0, FLDA% TEMP,1+ +TBIN1, SETX VALID / XR POINTER ONTO VALID VECTOR + ATX X0 / INSERT V. VALUE INTO THE VECTOR (WORD BY WORD) + SETX TBIN1 / NOW WE INCREMENT THE POINTER ABOVE + JXN .+2,X1+ / WITH THE X INCREMENT CMD AND + SETX XR0 / RESET TO THE INDEX REGISTER SET + JXN THL0,X2+ / AND NOW WE TEST IF THE WORK IS DONE + TH5, STARTF / CLEAR ALL 36 BITS OF FAC SINCE + FCLA / IF NTRIG.EQ.0 THEN WE DO NOT LOAD INTO THE EXPONENT + STARTD + FLDA NTRIG / PREPARE THE STRIGG EVENT INPUT + JEQ TH7 / NOTHING DESIRED, SKIP TO TH7 + LDX 10,X0 / ERROR #10 + IFNSW 4 < / IF THERE IS NO HANDLER THEN + JA TH9 > / WE ERROR OFF + FSTA TEMP / PUT ADDR OF TRIGG COUNT --> TEMP + STARTF + FLDA% TEMP / # OF TRIGGER INPUTS --> FAC + LDX 11,X0 / ERROR #11 + JAL TH9 / IF NO FIXING POSSIBLE THE ERROR OFF! + JLT TH9 / IF TRIGGER NUMBER OUTSIDE RANGE 0 TO 3 THEN ERROR OFF + FSUB FL3 / TEST FOR UPPER LIMIT + LDX 12,X0 / ERROR #12 + JGT TH9 + FADD FL3 +TH7, STARTF / IF THERE ARE NO STRIGGS INPUT THEN WE COME HERE WITH FAC CLEARED! + FADD FL1 / ADD 1 FOR THE COUNTER OF THE IR SERVICE ROUTINE + FNEG / AND HERE WE COMPUTE THE COUNTER + SETX WSTRC / AND BUMP INTO PDP/8 CODE + ATX 0 + SETX XR0 / RESET INDEX REGIS POINTER + STARTD / ADDR OF TIME RATIO --> TEMP + FLDA TIMRAT / FETCH THE TIME RATIO + JEQ TH12 / NO STRIG EVENTS DISIRED, SKIP + FSTA TEMP + STARTF + FLDA% TEMP / TIMERATIO --> FAC + FSTA TIMRAT / AND SAVE FOR SOMEBODY ELSE + LDX 13,X0 / ERROR #13 + JLT TH9 / NEGATIVE PARAMETER IS NOT NICE + LDX 14,X0 / ERROR #14 + JAL TH9 / WE HAVE TO FIX THE NUMBER + JA TH11 +TH9,/ X0 HOLDS ERROR NUMBER (10 TO 13) + TRAP4 #ARGERR / WE ERROR OFF +/ +TH11, SETX TIMBIT / FIX THE NUMBER INTO 12 BITS + ATX 0 / FOR EAE DVI INSTRUCTION + SETX XR0 +/ +/ INDEX REGISTERS (PBUFF) 1&2 ARE STATUS WORD PNTRS! +/ +TH12, SETX PBUFF + LDX 11,1 /INITIALIZE STATUS WORD PNTRS + LDX 14,2 + FLDA FP25 /INITIALIZE STATUS WORDS + FSTA STAT1 /TO INDICATE BUFFERS + FSTA STAT2 /NOT FILLED + TRAP4 ADSETU /SET UP AD STUFF + FLDA NTRIG / HERE WE SET UP THE STRIGGE EVENT INPUT + STARTD + JEQ TH8 / IF NO TRIGG INPUTS THEN SKIP ELSE + FLDA TRGADR / + FSTA #CLINT / QUEUE THE STRIGG INTERRUPT SERVICE ROUTINE INTO THE CLOCK TERMINATION ROUTINE +TH8,/ + FLDA SAMADR /SET UP SAMPLER INTRPT HNDLR + FSTA CLINT + STARTF + JA SAMRTN /RETURN +NAME, TEXT +THRUPT+ + SETX XR0 + SETB BASEX +TRETU, F 0. +SAMADR, ADDR FSMPLE +TRGADR, ADDR FIREED / ADDR OF SCHMITT TRIGGER EVENT INTERRUPT SERVICE +/ +XR0, 0 +XR1, 0 / HOLDS NUMBER OF ARGUMENTS +XR2, 0 +XR3, 0 +X0= 0 +X1= X0+1 +X2= X1+1 +X3= X2+1 +ONE, 0;1;0 +TWO, 0;2;0 +FL1, F 1. +FL3, F 3. +PARAM, +CHNLS, F 0. +PCKSIG, F 0. +PACK, F 0. / HOLDS ADR. OF FOURTH ARGUMENT +NTRIG, F 0. / HOLDS ADDR. OF FIFTH ARGUMENT +TIMRAT, F 0. /HOLDS CLOCK/SAMRAT/12, CLOCK IS RATIO OF SCHMITT TRIGGER TIMER + /**** WORD SUBROUTINES **** +/ +WPCNT, 0;0 +WC1, 0;6 + BASE WDBASE +WDBASE, F 0. /PNTR TO ARGS +WDINDX, F 0. /INDEX TO WORD IN ARRAY +WDOPER, F 0. /TARGET OR SOURCE ADDR +F1, F 1. +STXMJA, 0;1100-1030;0 /STX - JA +WORDOP, TEXT +WORDOP+ + 0 +WDRTN, JA . +WINDEX, F 0. /INDEX REGS 0-2 +/ + ORG 10*3+WDBASE + 0 + JA WORDOP+3 +/ +/**** WGET - WORD GET **** +/ +/ CALL WGET(BUFF1,NWORD,Y) +/ + ENTRY WGET +WGET, JSA WDSET /INIT REGISTERS + FLDA WPCNT / LOOK IF CALLED WITH TWO PARAMETERS + JEQ W2PAR / TWO PARAMETERS ONLY, OUPUT VIA FAC + XTA 0 /GET WORD FROM BUFF1 + FSTA% WDOPER /STICK IT IN X + JA WDRTN +W2PAR, XTA 0 + JA WDRTN +/ +/**** WPUT - WORD PUT **** +/ +/ CALL WPUT(BUFF1,NWORD,Y) +/ + ENTRY WPUT +WPUT, JSA WDSET /INIT REGISTERS + FLDA% WDOPER /GET Y + ATX 0 /FIX AND STORE IN BUFF1 + JA WDRTN +/ +/ WGET & WPUT INITIALISATION +/ + BASE 0 +WDSET, 0;0 + STARTD + FLDA 30 /GET RTN ADDR + FSTA WDRTN + FLDA 0 /PNTR TO ARGS + SETB WDBASE + BASE WDBASE + SETX WINDEX + FSTA WDBASE + LDX 0,1 / COMPUTE NUMBER OF PARAMETERS + FLDA% WDBASE,1 / ADR. FOLLOWING THE PARAMETER LIST --> FAC + FSUB WDBASE / SUBTRACT THE START ADR. OF PARAMETER LIST + FSUB WC1 / FAC-5 --> FAC + FSTA WPCNT / WPCNT=0 <==> TWO PARAMETERS, =2 <==> THREE PARAMETERS + FLDA% WDBASE,1+ /BUFFER ADDR + FADD STXMJA /MAKE SETX INST + FSTA WDSETX + FLDA% WDBASE,1+ /WORD INDEX ADDR + FSTA WDINDX + FLDA WPCNT / TEST IF THERE ARE MORE THAN 2 PARAMETERS + JEQ WCONT / + FLDA% WDBASE,1+ /RESULT OR VALUE ADDR + FSTA WDOPER +WCONT, + STARTF + FLDA% WDINDX /WORD INDEX + FSUB F1 /COMPUT ADDR OF WORD + ALN 0 + STARTD + FADDM WDSETX +WDSETX, SETX 0 /MODIFIED DURING EXEC + STARTF + JA WDSET +/ SUBROUTINE TO RELEASE A BUFFER BY RESETTING +/ THE STATUS REGISTER +/ +/ CALL RELEAS(N) +/ +/ N DESIGNATES THE STATUS REGISTER, N SHOULD BE 1 +/ OR 2. IF N .NE. 1, 2 IS ASSUMED. +/ + ENTRY RELEAS + BASE 0 +RELEAS, STARTD + FLDA 30 /GET RTN ADDR + FSTA WDRTN + FLDA 0 /GET ARG PNTR + BASE WDBASE + SETB WDBASE + SETX WINDEX + FSTA WDBASE + LDX 1,1 + FLDA% WDBASE,1 /N ADDR + FSTA WDBASE + SETX STAT1 /MODIFY STATUS VIA INDEX + STARTF + FLDA% WDBASE /N + FSUB F1 /TEST FOR NOT 1 + JNE CLR2 /ASSUME STAT2 + LDX -1,0 /CHANGE EXPONENT + /TO -7 TO MAKE 0.25 + JA WDRTN +CLR2, LDX -1,3 /STAT2 EXP TO -1 + JA WDRTN + / COMPUTE THE NUMBER OF BITS SET IN THE TRIGGER WORD +/ INTEGER FUNCTION TRGWRD +/ BITCNT=TRGWRD(TIMEWORD) +/ + ENTRY TRGWRD + BASE 0 +TRGWRD, STARTD / STAY ON CALLER S BASE + FLDA 3*10 + FSTA RETS / SAVE RETURN ADR. + SETX BITSCN / SET UP X REGISTER TO 8-MODE CODE + LDX 1,1 / INDEX TO FIRST ARGUMENT + FLDA% 0,1 + FSTA 3 + STARTF + FLDA% 3 / FIRST ARGUMENT --> FAC + ATX 0 / AND INTO 8-MODE CODE + TRAP4 CMPBIT / THE WORK IS DONE BY PDP8 + XTA 1 / GET THE RESULT +RETS, JA .-. / AND HOME + END +  \ No newline at end of file