:code :setup bad power off :setup active force off :setup active interrupt off :setup beep on /* ********************************************************************** * memory board report. * * * * program 0 assigns variables for module 1. * * program 1 tests the memory. * * * ********************************************************************** ********************************************************************** * define the macros being used. * * * ********************************************************************** */ :rem Delay about 5 seconds before returning. This module is for the :rem reading of the bad contacts finder in module 1. :macro sleep ramp a5a5 repeat repeat repeat repeat repeat :endmacro :rem Check memory by writing a high into memory at reg8 or offset. :rem (Offset value is passed in a macro parameter called OFFSET.VALUE). :macro check.high #offset.value write reg8 or offset.value high read reg8 or offset.value compliment rege | rege = rege and high if rege > low goto 2 :endmacro :rem As with the previous macro, we will be checking memory but this :rem time we will be writing a low out to memory then checking it again. :macro check.low #offset.value write reg8 or offset.value low read reg8 or offset.value if rege > low goto 1 :endmacro /* ********************************************************************* * equate the programs entry points. * * * ********************************************************************* */ :equate entry.point as :next :equate check.memory as :next :equate ram.shorting as :next :equate dump.message as :next :equate screen.clear as :next :equate offer.cpu.bits as :next :rem Video status is memory mapped at address fc00 and video data :rem is memory mapped at address fc01. Here we equate them to :rem variable names to upgrade the readability of the code. :variable video.status as fc00 :variable video.data as fc01 :variable low as 0 :variable high as ff /* ********************************************************************** * Equate the status signals of the Z80 pod with the numeric * * values that represent them. This is used in the pre-test * * module that reads the status register and compares the bits * * within it against these variables to see if something is * * active. If it is active, the pre-tester publishes a message. * * * ********************************************************************** */ :variable power.fail with (10000000b) :variable reset with (00010000b) :variable interupt.request with (00001000b) :variable nonmaskable.interrupt with (00000100b) :variable ready.signal with (00000001b) :rem ***************************************************************** :rem * main entry point. * :Rem * Define where rom, and ram is located on an Ohio Scientific. * :rem * * :rem ***************************************************************** :rom fe00 ffff 179e :ram 0000 3fff :ram 4000 7fff :ram 8000 bfff /* ********************************************************************** * reg8 is the address to check * * reg9 is the board number being tested * * rega is the row number being tested * * regb is 0 if no faults 1 if one or more boards require repair * * regc is 1 yes, 0 no for ram-short of memory boards pass prelim * * regd is 1 for yes, 0 no for run unit under test after pass * * * ********************************************************************** */ :program entry.point execute screen.clear execute offer.cpu.bits regb = 0 display do ram-short if pass?c display do run-uut if pass?d label 4 aux | aux - memory board testing report - display - memory test being run - :rem ***************************************************************** :rem * reset the video input/output chip * :rem * write 3, b5, to program the 6850 chip * :rem * * :rem ***************************************************************** write video.status 03 | write video.status b5 read video.status | if rege and 82 = 82 goto 0 display video chip wont program $e aux video chip wont program we get $e label 0 aux | aux - board 1 being tested - reg9 = 1 | read 0000 | rega = rege :sleep read 0000 | if rege = rega goto 1 | goto f label 1 rega = 1 | reg8 = 0000 | execute check.memory rega = 2 | reg8 = 1000 | execute check.memory rega = 3 | reg8 = 2000 | execute check.memory rega = 4 | reg8 = 3000 | execute check.memory aux - board 2 being tested - reg9 = 2 | read 4000 | rega = rege :sleep read 4000 | if rega = rege goto 2 | goto f label 2 rega = 1 | reg8 = 4000 | execute check.memory rega = 2 | reg8 = 5000 | execute check.memory rega = 3 | reg8 = 6000 | execute check.memory rega = 4 | reg8 = 7000 | execute check.memory aux - board 3 being tested - reg9 = 3 | read 8000 | rega = rege :sleep read 8000 | if rege = rega goto 3 | goto f label 3 rega = 1 | reg8 = 8000 | execute check.memory rega = 2 | reg8 = 9000 | execute check.memory rega = 3 | reg8 = a000 | execute check.memory rega = 4 | reg8 = b000 | execute check.memory aux | aux - done with memory board testing. result are above - display - done - | execute ram.shorting | stop :rem ***************************************************************** :rem * enter here when a number is read twice and * :rem * two different numbers are aquired. there is * :rem * a possible bad connetction on the board * :rem * * :rem ***************************************************************** label f aux aux board number @9 looks like it has bad contacts with aux the motherboard. i am not getting a solid fault aux reading on. check and tighten contacts, then rerun aux this test by hitting cont aux display please read printer | stop | goto 4 :program check.memory :check.low 000 :check.low 100 :check.low 200 :check.low 300 :check.low 400 :check.low 500 :check.low 600 :check.low 700 :check.low 800 :check.low 900 :check.low a00 :check.low b00 :check.low c00 :check.low d00 :check.low e00 :check.low f00 :check.high 000 :check.high 100 :check.high 200 :check.high 300 :check.high 400 :check.high 500 :check.high 600 :check.high 700 :check.high 800 :check.high 900 :check.high a00 :check.high b00 :check.high c00 :check.high d00 :check.high e00 :check.high f00 goto 3 label 1 :rem ***************************************************************** :rem * bits failed at low bit test * :rem * * :rem ***************************************************************** aux address $f, board $9, row $a, bits are not low, pattern $e, chips + display $f $9 $a $e goto 4 label 2 :rem ***************************************************************** :rem * bits failed at high bit test * :rem * * :rem ***************************************************************** aux address $f, board $9, row $a, bits are not high, pattern $e, chips + display $f $9 $a $e :rem ***************************************************************** :rem * display the chip numbers that are in the pattern * :rem * * :rem ***************************************************************** label 4 regb = 1 reg1 = rege reg2 = 1 reg3 = 1 label 7 reg4 = rege and reg2 if reg4 = reg2 goto 5 label 8 increment reg3 shift-left reg2 if reg3 = 9 goto 6 goto 7 label 5 aux $3, + display + $3 goto 8 label 6 aux label 3 /* ********************************************************************** * This module will execute a ram-short on each board one at a time. * * There are three memory boards. After it passes, (if it passes), it * * will execute a ram-long test on the first 51 memory address of * * each board to detect any pattern sensitivity problems within those * * memory cells. * * * ********************************************************************** */ :program ram.shorting if regc = low goto 1 | if regb = 1 goto 1 aux - testing with ram-short - display ram-short board 1 | aux - ram-short board 1 - | ram-short 0000 3fff display ram-short board 2 | aux - ram-short board 2 - | ram-short 4000 7fff display ram-short board 3 | aux - ram-short board 3 - | ram-short 8000 bfff display ram-long 0000 0050 | aux ram-long 0000 0050 | ram-long 0000 0050 display ram-long 4000 4050 | aux ram-long 4000 4050 | ram-long 4000 4050 display ram-long 8000 8050 | aux ram-long 8000 8050 | ram-long 8000 8050 aux - testing done - | display - ram-short done - if regd = low goto 1 | run | display running unit under test label 1 :rem ***************************************************************** :rem * terminate execution because of a failure in previous test * :rem * * :rem ***************************************************************** :rem ***************************************************************** :rem * clear the screen by dumping some line feeds to it. * :rem * * :rem ***************************************************************** :program screen.clear :for reg0 = 1 to 25# at 0 aux :next :rem ***************************************************************** :rem * here we will display the active signals. * :rem * * :rem ***************************************************************** :program offer.cpu.bits read status reg1 = regc and power.fail reg2 = regc and reset reg3 = regc and interupt.request reg4 = regc and nonmaskable.interrupt reg5 = regc and ready.signal if reg1 = power.fail goto 1 label 7 if reg2 = 0 goto 2 label 8 if reg3 = 0 goto 3 label 9 if reg4 = 0 goto 4 label a if reg5 = ready.signal goto 5 goto 6 label 1 aux unit under test is in a power fail condition # goto 7 label 2 aux unit under test is in a reset condition # goto 8 label 3 aux unit under test is in an interupt request condition # goto 9 label 4 aux unit under test is in a nonmaskable interrupt condition # goto a label 5 aux unit under test is ready label 6