// Resist.bcpl -- board open/short tester -- main program and utilities
// Last modified by June 25, 1984 12:35 PM
get "Resist.decl"
get "Streams.d"
get "AltoDefs.d"
get "SysDefs.d"
external
[
// outgoing procedures
EncodeOhms; DecodeOhms; OhmsCodeTable
ReportError; PermAllocate; ExpandTemplate; ResistFinish; Confirm
// incoming procedures
InitResist; ICState; ReEstablishStream
ReadResistFile; ReadWireListFile; UnparseIC; SummarizeBadNets
CreateSymbolTable; EnumerateSymbolTable
DefineSymbol; LookupSymbol; LookupOrDefineSymbol; MustLookupSymbol
SymbolsObject; SymbolsString; ObjectsString; SymbolsType; PinsNetSymbol
DisplayIC; DisplaySingleOhms; DisplayOhms
ShowFullDisplay; FlashWindow
MeasureOhms; SignalOn; PulseChannel; Wait
DeleteFile; RenameFile; CleanupDiskStream
CreateStringStream; ConcatenateStrings; ExtractSubstring
PutTemplate; ResetLine; EraseBits; CharWidth
Ws; Wss; Gets; Puts; Resets; Closes; Endofs
Allocate; Free; AddToZone
Usc; Max; SysErr; Junta
// outgoing statics
endInitCode; permZone; version; startLocation; serialNumber; errorTolerance
maxNPins; resistSavedUFP; displayInterruptMask
resStream; exStream; wlStream; outStream
resName; outName; mustRename; stuffed; restart
stateCFA; outCFA; symbolTable; ohmsCodeTab
// incoming statics
sysZone; dsp; keys; statusDsp; lvUserFinishProc; stateStream
]
static
[
endInitCode
resStream = 0
exStream = 0
wlStream = 0
outStream = 0
serialNumber = 0
startLocation = 0
maxNPins = defaultMaxNPins
resistSavedUFP; displayInterruptMask
resName; outName; mustRename
stuffed = 1
errorTolerance = 0
lastChar; version
permZone; symbolTable
symDIP3; symMB7071H; symSpareSocket; symAUGATCG16; symUnknownNet
restart = false
stateCFA; outCFA
ohmsCodeTab
]
manifest [ normal = 0; quit = 1; ignore = 2; repeatIC = 3 ] // command action
manifest maxPass = 5
// ---------------------------------------------------------------------------
let Resist() be
// ---------------------------------------------------------------------------
[
version = "Resist of June 25, 1984"
Junta(levDisplay, ResistAfterJunta)
]
// ---------------------------------------------------------------------------
and ResistAfterJunta() be
// ---------------------------------------------------------------------------
[
InitResist()
AddToZone(sysZone, InitResist, endInitCode-InitResist)
Ws("*nReading Resist file...")
symbolTable = CreateSymbolTable(251, permZone)
symDIP3 = LookupOrDefineSymbol(symbolTable, "DIP3", stICPackage)
symMB7071H = LookupOrDefineSymbol(symbolTable, "MB7071H", stICType)
symSpareSocket = LookupOrDefineSymbol(symbolTable, "SpareSocket", stICType)
symAUGATCG16 = LookupOrDefineSymbol(symbolTable, "AUGATCG16", stICType)
let firstIC = ReadResistFile(resStream, symbolTable)
Closes(resStream)
if exStream ne 0 then
[
Ws("*nReading Exceptions file...")
ReadResistFile(exStream, symbolTable, true)
Closes(exStream)
]
Ws("*nReading Wire List file...")
ReadWireListFile(wlStream, symbolTable)
Closes(wlStream)
symUnknownNet = MustLookupSymbol(symbolTable, "?")
stateStream = ReEstablishStream(stateCFA, ksTypeReadWrite, wordItem)
if restart then
[
Ws("*nRestoring results from interrupted test...")
until Endofs(stateStream) do
startLocation = ObjectsString(ICState(true, nil))
]
let freeWords = nil
Allocate(sysZone, 77777B, lv freeWords)
PutTemplate(dsp, "*n$D+$D free words remaining.*nReady to begin testing.",
freeWords, permZone>>PermZone.wordsLeft)
let ic = firstIC
let firstPass = 1
if startLocation ne 0 then
[
let symbol = LookupSymbol(symbolTable, startLocation)
test symbol eq 0
ifso ReportError("Board location $S undefined", startLocation)
ifnot
[
ic = SymbolsObject(symbol)
firstPass = WhichPassForIC(ic)
if firstPass eq 0 then firstPass = 1
]
]
ShowFullDisplay(true)
let action = nil
for pass = firstPass to maxPass do
[
action = DoPass(lv pass, ic)
if action eq quit then break
ic = firstIC
]
unless action eq quit do
[
ShowFullDisplay(false)
Ws("*nWriting defects file...")
Closes(stateStream)
outStream = ReEstablishStream(outCFA, ksTypeWriteOnly, charItem)
let badUnknownNets = ReportDefects(firstIC, outStream)
SummarizeBadNets(outStream, symbolTable, InTolerance)
if badUnknownNets ne 0 then
PutTemplate(outStream, "*n; There are $D errors involving pins whose net names are not known.*n",
badUnknownNets)
Closes(outStream)
if mustRename then
[
let backupName = ConcatenateStrings(outName, "$")
DeleteFile(backupName)
RenameFile(outName, backupName)
RenameFile("Resist.temp$", outName)
PutTemplate(dsp, "*nInput file renamed to $S.", backupName)
Free(sysZone, backupName)
]
Free(sysZone, outName)
DeleteFile("Resist.state$")
]
@displayListHead = 0
finish
]
// ---------------------------------------------------------------------------
and DoPass(lvPass, ic) = valof
// ---------------------------------------------------------------------------
[ // repeat
let action = normal
if ic eq 0 resultis action
if WhichPassForIC(ic) eq @lvPass then
[
PutTemplate(statusDsp, " Location $S ($S) $D-pin*n",
ObjectsString(ic), SymbolsString(ic>>IC.type), ic>>IC.nPins)
let Measure = HowToMeasure(ic)
[ // repeat
switchon Measure(ic) into
[
case $*s:
break
case $D:
Measure = MeasureMultiple; endcase
case $S:
Measure = MeasureSingle; endcase
case $Q:
if Confirm() then [ action = quit; SetAllUnknown(ic); break ]
endcase
case $I:
if Confirm() then [ action = ignore; SetAllUnknown(ic); break ]
endcase
case $L:
[
let location = GetString()
if location ne 0 then
[
let icSymbol = LookupSymbol(symbolTable, location)
Free(sysZone, location)
test icSymbol eq 0 % SymbolsType(icSymbol) ne stIC
ifso Ws("*nBoard location not defined.")
ifnot
[
SetAllUnknown(ic)
ic = SymbolsObject(icSymbol)
@lvPass = WhichPassForIC(ic)
action = repeatIC
break
]
]
endcase
]
]
] repeat
Resets(statusDsp)
if action eq normal then
[ ICState(false, ic); CleanupDiskStream(stateStream) ]
]
if action eq quit resultis action
unless action eq repeatIC do ic = ic>>IC.next
] repeat
// ---------------------------------------------------------------------------
and WhichPassForIC(ic) = valof
// ---------------------------------------------------------------------------
// Returns the pass during which it is appropriate to test this IC,
// or 0 if the IC should never be tested.
// 1: 16- and 14-pin DIPs, except Spare and Platforms if board is stuffed
// 2: Spare if board is stuffed
// 3: 24-pin DIPs
// 4: QIT packages
// 5: Everything else (including Platforms if board is stuffed)
[
for pinNumber = 1 to ic>>IC.nPins do
if ic>>IC.pins↑pinNumber.expectedOhmsCode ne unknownCode then
[
resultis ic>>IC.package eq symDIP3?
selecton ic>>IC.nPins into
[
case 16: // 16-pin DIP3
stuffed?
(ic>>IC.type eq symSpareSocket? 2,
ic>>IC.type eq symAUGATCG16? 5, 1), 1
case 14: 1 // 14-pin DIP3
case 2: 0 // 2-pin "DIP3"s are bypass capacitors -- don't test
default: 5 // Oddball DIP3 (not sure this can ever happen)
],
selecton ic>>IC.nPins into
[
case 26: 4 // QIT package
case 24: 3 // 24-pin DIP
case 8: 0 // SIP -- don't test
default: 5 // Oddball, test with single probe
]
]
// All the pins of this IC have unknown resistance
resultis 0
]
// ---------------------------------------------------------------------------
and HowToMeasure(ic) =
// ---------------------------------------------------------------------------
WhichPassForIC(ic) eq 5 % (ic>>IC.nPins eq 26 & stuffed)?
MeasureSingle, MeasureMultiple
// ---------------------------------------------------------------------------
and MeasureMultiple(ic) = valof
// ---------------------------------------------------------------------------
[
ResetLine(statusDsp)
PutTemplate(statusDsp, "Install $S probe; press switch when ready",
(ic>>IC.type eq symMB7071H? "QIT", "DIP"))
Resets(keys)
let probeState = 0
[ // repeat
let ok = true
let allOpen = true
for pinNumber = 1 to ic>>IC.nPins do
[
let pin = lv ic>>IC.pins↑pinNumber
pin>>Pin.measuredOhmsCode =
EncodeOhms(MeasureOhms(PinChannel(ic, pinNumber)))
ok = ok & InTolerance(pin)
allOpen = allOpen & pin>>Pin.measuredOhmsCode eq openCode
]
DisplayIC(ic, InTolerance)
DisplaySingleOhms(MeasureOhms(chanSingle))
probeState = selecton probeState into
[
case 0: allOpen? 1, 0
case 1: allOpen? 1, 2
case 2: 2
]
SignalOn(probeState eq 2 & not ok)
] repeatuntil CheckKeys()
SignalOn(false)
resultis lastChar // returned by CheckKeys
]
// ---------------------------------------------------------------------------
and PinChannel(ic, pinNumber) =
// ---------------------------------------------------------------------------
(chanPin1-1) + selecton ic>>IC.nPins into
[
case 14: pinNumber ls 8? pinNumber, pinNumber+2
case 26: pinNumber le 24? pinNumber, 24
default: pinNumber
]
// ---------------------------------------------------------------------------
and MeasureSingle(ic) = valof
// ---------------------------------------------------------------------------
[
let nPins = ic>>IC.nPins
for pinNumber = 1 to nPins do
[
ResetLine(statusDsp)
PutTemplate(statusDsp,
"Install single probe on pin $D and press switch", pinNumber)
Resets(keys)
[ // repeat
let pin = lv ic>>IC.pins↑pinNumber
pin>>Pin.measuredOhmsCode =
EncodeOhms(MeasureOhms(chanSingle))
ic>>IC.nPins = pinNumber
DisplayIC(ic, InTolerance)
ic>>IC.nPins = nPins
DisplaySingleOhms(MeasureOhms(chanSingle))
SignalOn(not InTolerance(pin))
// for current tracer, pulse the channel for 100 ms and then
// leave it off for 100 ms.
PulseChannel(chanSingle, 100/17)
Wait(100/17)
] repeatuntil CheckKeys()
switchon lastChar into
[
case $*s:
endcase
case $B: // Back up
if pinNumber gr 1 then pinNumber = pinNumber-2 // +1 in for loop
endcase
default:
break
]
]
SignalOn(false)
if lastChar eq $*s then
[
ResetLine(statusDsp)
Wss(statusDsp, "Press switch when ready for next IC.")
Resets(keys)
until CheckKeys() do loop
]
resultis lastChar
]
// ---------------------------------------------------------------------------
and InTolerance(pin) = valof
// ---------------------------------------------------------------------------
[
if pin>>Pin.expectedOhmsCode eq unknownCode resultis true
let exp = DecodeOhms(pin>>Pin.expectedOhmsCode)
let diff = DecodeOhms(pin>>Pin.measuredOhmsCode) - exp
diff = Max(diff, -diff) // Abs(diff)
resultis diff le (errorTolerance*
(exp ls 33? 33, exp) + 50)/100
]
// ---------------------------------------------------------------------------
and ReportDefects(firstIC, stream) = valof
// ---------------------------------------------------------------------------
// Returns the number of pins that are out-of-tolerance and connected
// to net "?".
[
let badUnknownNets = 0
while firstIC ne 0 do
[
CheckForDefect(firstIC, stream, lv badUnknownNets)
firstIC = firstIC>>IC.next
]
resultis badUnknownNets
]
// ---------------------------------------------------------------------------
and CheckForDefect(ic, stream, lvBadUnknownNets) be
// ---------------------------------------------------------------------------
[
let firstError = true
for pinNumber = 1 to ic>>IC.nPins do
[
let pin = lv ic>>IC.pins↑pinNumber
unless pin>>Pin.measuredOhmsCode eq unknownCode % InTolerance(pin) do
[
if firstError then
[ Puts(stream, $*n); UnparseIC(stream, ic) ]
firstError = false
PutTemplate(stream, "; Pin $2D expected resistance: ", pinNumber)
DisplayOhms(stream, DecodeOhms(pin>>Pin.expectedOhmsCode))
Wss(stream, ", measured: ")
DisplayOhms(stream, DecodeOhms(pin>>Pin.measuredOhmsCode))
let symPin = PinsNetSymbol(pin)
PutTemplate(stream, ". Net $S*n", SymbolsString(symPin))
if symPin eq symUnknownNet then @lvBadUnknownNets = @lvBadUnknownNets+1
]
]
]
// ---------------------------------------------------------------------------
and SetAllUnknown(ic) be
// ---------------------------------------------------------------------------
for pinNumber = 1 to ic>>IC.nPins do
ic>>IC.pins↑pinNumber.measuredOhmsCode = unknownCode
// ---------------------------------------------------------------------------
and CheckKeys() = valof
// ---------------------------------------------------------------------------
// Returns true if a key has been struck or the switch depressed.
// Stores the character into lastChar (depressed switch => $*s)
[ // repeat
if Endofs(keys) resultis false
lastChar = Gets(keys)
if lastChar ge $a & lastChar le $z then lastChar = lastChar - ($a-$A)
switchon lastChar into
[
case $D:
Ws("*nDIP probe"); endcase
case $S:
Ws("*nSingle probe"); endcase
case $B:
Ws("*nBack up"); endcase
case $I:
Ws("*nIgnore this IC"); endcase
case $L:
Ws("*nLocation: "); endcase
case $Q:
Ws("*nQuit"); endcase
case $*s:
endcase
default:
FlashWindow(dsp)
case $?:
Ws("*n? Depress switch or strike space bar to advance .")
Ws("*nCommands are:")
Ws("*nDIP probe, Single probe, Back up, Ignore IC, Location, Quit.")
loop
]
resultis true
] repeat
// ---------------------------------------------------------------------------
and GetString() = valof
// ---------------------------------------------------------------------------
[
let string = vec 127
let length = 0
[ // repeat
let char = Gets(keys)
switchon char into
[
case $*001:
case $*010:
if length gr 0 then
[
EraseBits(dsp, -CharWidth(dsp, string>>String.char↑length))
length = length-1
]
endcase
case $*n:
case $*033:
break
case $*177:
Ws(" XXX")
resultis 0
default:
unless length eq 255 do
[
length = length+1
string>>String.char↑length = char
Puts(dsp, char)
]
endcase
]
] repeat
string>>String.length = length
resultis ExtractSubstring(string)
]
// ---------------------------------------------------------------------------
and Confirm() = valof
// ---------------------------------------------------------------------------
[
Ws(" [Confirm] ")
switchon Gets(keys) into
[
case $Y: case $y: case $*n:
Ws("yes"); resultis true
case $N: case $n: case $*177:
Ws("no"); resultis false
default:
FlashWindow(dsp); Resets(keys); endcase
] repeat
]
// ---------------------------------------------------------------------------
and ReportError(template, arg1, arg2, arg3, arg4, arg5) be
// ---------------------------------------------------------------------------
[
Ws("*n")
PutTemplate(dsp, template, arg1, arg2, arg3, arg4, arg5)
Ws(" (more?...)")
Resets(keys)
Gets(keys)
Resets(dsp)
]
//----------------------------------------------------------------------------
and PermAllocate(zone, words) = valof
//----------------------------------------------------------------------------
[ // repeat
if words gr zone>>PermZone.threshold then
resultis Allocate(zone>>PermZone.underlyingZone, words)
if words gr zone>>PermZone.wordsLeft then
[
zone>>PermZone.currentBlock =
Allocate(zone>>PermZone.underlyingZone, permIncrement, true)
if zone>>PermZone.currentBlock eq 0 then
// If failed to allocate, do all future allocations directly from zone
[ zone>>PermZone.threshold = 0; loop ]
zone>>PermZone.wordsLeft = permIncrement
]
let result = zone>>PermZone.currentBlock
zone>>PermZone.currentBlock = zone>>PermZone.currentBlock + words
zone>>PermZone.wordsLeft = zone>>PermZone.wordsLeft - words
resultis result
] repeat
//----------------------------------------------------------------------------
and ExpandTemplate(template, arg1, arg2, arg3, arg4, arg5) = valof
//----------------------------------------------------------------------------
[
let string = vec 127
let ss = CreateStringStream(string, 255)
PutTemplate(ss, template, arg1, arg2, arg3, arg4, arg5)
Closes(ss)
resultis ExtractSubstring(string)
]
//----------------------------------------------------------------------------
and ResistFinish() be
//----------------------------------------------------------------------------
[
@displayInterrupt = @displayInterrupt & not displayInterruptMask
@lvUserFinishProc = resistSavedUFP
]
//----------------------------------------------------------------------------
and Wss(stream, string) be
//----------------------------------------------------------------------------
for i = 1 to string>>String.length do Puts(stream, string>>String.char↑i)
//----------------------------------------------------------------------------
and Ws(string) be Wss(dsp, string)
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
and EncodeOhms(ohms) = valof
//----------------------------------------------------------------------------
[
switchon ohms into
[
case unknown: resultis unknownCode
case open: resultis openCode
default:
[
if ohms ge ohmsCodeTab!31 then resultis openCode
let power = 0
let mantissa = 2*(50+Max(ohms, 0))
while mantissa ls ohmsCodeTab!31 do
[
power = power+1
mantissa = mantissa+mantissa
]
for i = 0 to 31 do
if mantissa ge ohmsCodeTab!i then resultis 32*power+i
]
]
]
//----------------------------------------------------------------------------
and DecodeOhms(ohmsCode) = valof
//----------------------------------------------------------------------------
[
switchon ohmsCode into
[
case unknownCode: resultis unknown
case openCode: resultis open
default: resultis Max(0, ((((ohmsCodeTab!(ohmsCode & 37B)) rshift
(ohmsCode rshift 5))+1)/2)-50)
]
]
//----------------------------------------------------------------------------
and OhmsCodeTable() = valof
//----------------------------------------------------------------------------
[
resultis table [
10080;9864;9652;9446;9243;9045;8852;8662;8476;8294;8117;7943;7773
7606;7443;7284;7128;6975;6825;6679;6536;6396;6258;6125;5994;5865
5739;5616;5496;5378;5263;5150 ]
// (4990+50)*2↑(1-i/32)
]