LarkWorkCommandsC.mesa
L. Stewart, December 22, 1983 2:49 pm
DIRECTORY
Basics USING [BITAND, LowHalf],
Convert USING [CardFromRope, Error],
IO,
LarkControl USING [LarkData],
LarkPrograms USING [FindVariable, PatchFromFile, PatchItem, ProcedureEnclosing, STObject],
LarkWork USING [LarkWorkProc, RegisterLarkWorkProc],
Rope USING [ROPE],
RPCPkt,
TeleLoad USING [CoreAddress, Failed, FlushWrites, Handle, Read, ReadWord, ResetCache, SetCacheSize, WriteWord];
LarkWorkCommandsC: CEDAR PROGRAM
IMPORTS Basics, Convert, IO, LarkPrograms, LarkWork, TeleLoad =
BEGIN
BadCommRope: Rope.ROPE = "Communications Failure\n";
BadArgsRope: Rope.ROPE = "Bad Arguments\n";
Types
ShortCoreAddress: TYPE = CARDINAL;
ECB:
TYPE =
RECORD [
link: ShortCoreAddress,
kp: ShortCoreAddress,
srcp: ShortCoreAddress,
dstp: ShortCoreAddress,
count: CARDINAL,
encrypt: CARDINAL, -- BOOL
item: CARDINAL,
proc: ShortCoreAddress
];
Byte: TYPE = [0..377B];
LarkPORT:
TYPE =
RECORD [
net: Byte,
host: Byte,
a: CARDINAL,
b: CARDINAL
];
Queue:
TYPE =
RECORD [
head: ShortCoreAddress,
tail: ShortCoreAddress
];
VCB:
TYPE =
RECORD [
active: CARDINAL,
lport: LarkPORT,
rport: LarkPORT,
numPackets: CARDINAL,
lastEndTime: CARDINAL,
bufbase: ShortCoreAddress,
vpq: Queue,
pq: Queue,
pqlength: CARDINAL,
loECB: ECB,
hiECB: ECB,
floECB: ECB,
fhiECB: ECB,
now: CARDINAL,
silThresh: CARDINAL,
silVal: ShortCoreAddress,
encIndex: CARDINAL,
squelchTail: CARDINAL,
expPlayTime: CARDINAL,
firstPacket: CARDINAL,
daECB: ECB,
dbECB: ECB,
lsoc: CARDINAL,
dtimer: CARDINAL,
gainChannel: CARDINAL,
lastEnergy: CARDINAL,
gainCount: CARDINAL,
decayTime: CARDINAL,
gainLevel: CARDINAL,
gainTable: ARRAY [0..5) OF CARDINAL,
expPktID: CARDINAL
];
PrintECB:
PROC [lark: LarkControl.LarkData, out:
IO.
STREAM, ecb:
ECB] = {
out.PutF["ECB[link: %04xH, kp: %04xH, srcp: %04xH, dstp: %04xH, ", IO.card[ecb.link], IO.card[ecb.kp], IO.card[ecb.srcp], IO.card[ecb.dstp]];
out.PutF["count: %d,\n encrypt: %04xH, item: %04x, proc: %04x", IO.card[ecb.count], IO.card[ecb.encrypt], IO.card[ecb.item], IO.card[ecb.proc]];
out.PutF["(%g)]", IO.rope[LarkPrograms.ProcedureEnclosing[lark.program, ecb.proc].id]];
};
PrintPort:
PROC [lark: LarkControl.LarkData, out:
IO.
STREAM, port: LarkPORT] = {
out.PutF["%b#%b#%b,%b", IO.card[port.net], IO.card[port.host], IO.card[port.a], IO.card[port.b]];
};
PrintQueue:
PROC [lark: LarkControl.LarkData, out:
IO.
STREAM, q: Queue, max:
NAT, printTail:
BOOL ←
TRUE] = {
v, lastv: ShortCoreAddress;
v ← q.head;
out.PutRope["[ "];
FOR i:
NAT
IN [0..max)
DO
lastv ← v;
IF v = 0 THEN EXIT;
out.PutF["%04xH", IO.card[v]];
v ← TeleLoad.ReadWord[lark.h, v];
IF v = 0 THEN EXIT;
out.PutRope[", "];
REPEAT
FINISHED => out.PutRope["..."];
ENDLOOP;
out.PutRope[" ]"];
IF printTail
THEN {
IF lastv = q.tail THEN out.PutRope["(ok)"] ELSE out.PutF["(tail: %04xH)", IO.card[q.tail]];
};
};
PrintVCB:
PROC [lark: LarkControl.LarkData, out:
IO.
STREAM, vcb:
VCB, vcbIndex:
NAT] = {
out.PutF[IF vcb.active # 0 THEN "VCB %d Active\n" ELSE "VCB %d inactive\n", IO.card[vcbIndex]];
out.PutRope[" local: "];
PrintPort[lark: lark, out: out, port: vcb.lport];
out.PutRope[" remote: "];
PrintPort[lark: lark, out: out, port: vcb.rport];
out.PutRope["\n"];
out.PutF[" numPackets: %d, lastEndTime: %04xH, bufbase: %04xH\n", IO.card[vcb.numPackets], IO.card[vcb.lastEndTime], IO.card[vcb.bufbase]];
out.PutRope[" vpq: "];
PrintQueue[lark: lark, out: out, q: vcb.vpq, max: 8];
out.PutRope["\n"];
out.PutRope[" pq: "];
PrintQueue[lark: lark, out: out, q: vcb.pq, max: 8];
out.PutRope["\n"];
out.PutF[" pqlength: %d\n", IO.card[vcb.pqlength]];
out.PutRope[" loECB: "];
PrintECB[lark: lark, out: out, ecb: vcb.loECB];
out.PutRope["\n"];
out.PutRope[" hiECB: "];
PrintECB[lark: lark, out: out, ecb: vcb.hiECB];
out.PutRope["\n"];
out.PutRope[" floECB: "];
PrintECB[lark: lark, out: out, ecb: vcb.floECB];
out.PutRope["\n"];
out.PutRope[" fhiECB: "];
PrintECB[lark: lark, out: out, ecb: vcb.fhiECB];
out.PutRope["\n"];
out.PutF[" now: %04xH, silThresh: %04xH, silVal: %04xH\n", IO.card[vcb.now], IO.card[vcb.silThresh], IO.card[vcb.silVal]];
out.PutF[" encIndex: %d, squelchTail: %d, expPlayTime: %04xH, firstPacket: %04xH\n", IO.card[vcb.encIndex], IO.card[vcb.squelchTail], IO.card[vcb.expPlayTime], IO.card[vcb.firstPacket]];
out.PutRope[" daECB: "];
PrintECB[lark: lark, out: out, ecb: vcb.daECB];
out.PutRope["\n"];
out.PutRope[" dbECB: "];
PrintECB[lark: lark, out: out, ecb: vcb.dbECB];
out.PutRope["\n"];
out.PutF[" lsoc: %04xH, dtimer: %04xH\n", IO.card[vcb.lsoc], IO.card[vcb.dtimer]];
out.PutF[" gainChannel: %d, lastEnergy: %x, gainCount: %d\n", IO.card[vcb.gainChannel], IO.card[vcb.lastEnergy], IO.card[vcb.gainCount]];
out.PutF[" decayTime: %d, gainLevel: %d\n", IO.card[vcb.decayTime], IO.card[vcb.gainLevel]];
out.PutF[" gainTable 0: %4x, 1: %4x, 2: %4x", IO.card[vcb.gainTable[0]], IO.card[vcb.gainTable[1]], IO.card[vcb.gainTable[2]]];
out.PutF[" 3: %4x, 4: %4x\n", IO.card[vcb.gainTable[3]], IO.card[vcb.gainTable[4]]];
out.PutF[" expPktID: %04xH\n", IO.card[vcb.expPktID]];
};
ReadVCB:
PROC [h: TeleLoad.Handle, vcbAddr: TeleLoad.CoreAddress]
RETURNS [vcb:
VCB] = {
offset: NAT ← 0;
Next:
PROC
RETURNS [v:
CARDINAL] = {
v ← TeleLoad.ReadWord[h, vcbAddr + offset];
offset ← offset + 2;
};
ReadECB:
PROC
RETURNS [ecb:
ECB] = {
ecb.link ← Next[];
ecb.kp ← Next[];
ecb.srcp ← Next[];
ecb.dstp ← Next[];
ecb.count ← Next[];
ecb.encrypt ← Next[];
ecb.item ← Next[];
ecb.proc ← Next[];
};
ReadPort:
PROC
RETURNS [port: LarkPORT] = {
port.net ← TeleLoad.Read[h, vcbAddr + offset];
offset ← offset + 1;
port.host ← TeleLoad.Read[h, vcbAddr + offset];
offset ← offset + 1;
port.a ← Next[];
port.b ← Next[];
};
ReadQueue:
PROC
RETURNS [q: Queue] = {
q.head ← Next[];
q.tail ← Next[];
};
vcb.active ← Next[];
vcb.lport ← ReadPort[];
vcb.rport ← ReadPort[];
vcb.numPackets ← Next[];
vcb.lastEndTime ← Next[];
vcb.bufbase ← Next[];
vcb.vpq ← ReadQueue[];
vcb.pq ← ReadQueue[];
vcb.pqlength ← Next[];
vcb.loECB ← ReadECB[];
vcb.hiECB ← ReadECB[];
vcb.floECB ← ReadECB[];
vcb.fhiECB ← ReadECB[];
vcb.now ← Next[];
vcb.silThresh ← Next[];
vcb.silVal ← Next[];
vcb.encIndex ← Next[];
vcb.squelchTail ← Next[];
vcb.expPlayTime ← Next[];
vcb.firstPacket ← Next[];
vcb.daECB ← ReadECB[];
vcb.dbECB ← ReadECB[];
vcb.lsoc ← Next[];
vcb.dtimer ← Next[];
vcb.gainChannel ← Next[];
vcb.lastEnergy ← Next[];
vcb.gainCount ← Next[];
vcb.decayTime ← Next[];
vcb.gainLevel ← Next[];
vcb.gainTable[0] ← Next[];
vcb.gainTable[1] ← Next[];
vcb.gainTable[2] ← Next[];
vcb.gainTable[3] ← Next[];
vcb.gainTable[4] ← Next[];
vcb.expPktID ← Next[];
};
DspVCB: LarkWork.LarkWorkProc = {
ENABLE {
Convert.Error => GOTO BadArgs;
TeleLoad.Failed => GOTO BadComm;
};
out: IO.STREAM ← lark.h.log;
vcbAddr: TeleLoad.CoreAddress;
vcbIndex: CARDINAL;
vcbItem: LarkPrograms.STObject;
found: BOOL;
vcb: VCB;
IF argv.argc > 1
THEN {
vcbIndex ← Basics.LowHalf[Convert.CardFromRope[argv[1]]];
IF vcbIndex > 4 THEN GOTO BadArgs;
};
[item: vcbItem, found: found] ← LarkPrograms.FindVariable[lark.program, "vcb"];
IF found THEN vcbAddr ← vcbItem.addr
ELSE RETURN["can't get symbol vcb\n"];
TeleLoad.ResetCache[lark.h];
IF argv.argc > 1 THEN PrintVCB[lark: lark, out: out, vcb: ReadVCB[h: lark.h, vcbAddr: vcbAddr + (2 * vcbIndex * SIZE[VCB])], vcbIndex: vcbIndex]
ELSE
FOR vcbIndex
IN [0..4]
DO
vcb ← ReadVCB[h: lark.h, vcbAddr: vcbAddr + (2 * vcbIndex * SIZE[VCB])];
IF vcb.active # 0 THEN PrintVCB[lark: lark, out: out, vcb: vcb, vcbIndex: vcbIndex];
ENDLOOP;
EXITS
BadArgs => RETURN[BadArgsRope];
BadComm => RETURN[BadCommRope];
};
ESSet: LarkWork.LarkWorkProc = {
ENABLE {
Convert.Error => GOTO BadArgs;
TeleLoad.Failed => GOTO BadComm;
};
pvcb: POINTER TO VCB;
offsetGainChannel: CARDINAL;
offsetLastEnergy: CARDINAL;
offsetDecayTime: CARDINAL;
offsetGainTable: CARDINAL;
vcbAddr: TeleLoad.CoreAddress;
vcbIndex: CARDINAL;
gainControl: CARDINAL;
decayTime: CARDINAL;
gainTable: ARRAY [0..5) OF CARDINAL;
vcbItem: LarkPrograms.STObject;
found: BOOL;
TRUSTED {
pvcb ← LOOPHOLE[0];
offsetGainChannel ← LOOPHOLE[@pvcb.gainChannel, CARDINAL] * 2;
offsetLastEnergy ← LOOPHOLE[@pvcb.lastEnergy, CARDINAL] * 2;
offsetDecayTime ← LOOPHOLE[@pvcb.decayTime, CARDINAL] * 2;
offsetGainTable ← LOOPHOLE[@pvcb.gainTable, CARDINAL] * 2;
};
IF argv.argc # 9 THEN GOTO BadArgs;
[item: vcbItem, found: found] ← LarkPrograms.FindVariable[lark.program, "vcb"];
IF found THEN vcbAddr ← vcbItem.addr
ELSE RETURN["can't get symbol vcb\n"];
vcbIndex ← Basics.LowHalf[Convert.CardFromRope[argv[1]]];
IF vcbIndex > 4 THEN GOTO BadArgs;
gainControl ← Basics.LowHalf[Convert.CardFromRope[argv[2]]];
IF gainControl NOT IN [0..3] THEN GOTO BadArgs;
decayTime ← Basics.LowHalf[Convert.CardFromRope[argv[3]]];
IF decayTime NOT IN [1..31] THEN GOTO BadArgs;
FOR i:
NAT
IN [0..5)
DO
gainTable[i] ← Basics.LowHalf[Convert.CardFromRope[argv[4+i]]];
ENDLOOP;
TeleLoad.ResetCache[lark.h];
TeleLoad.SetCacheSize[lark.h, 2];
vcbAddr ← vcbAddr + (vcbIndex * SIZE[VCB] * 2);
TeleLoad.WriteWord[h: lark.h, addr: vcbAddr + offsetGainChannel, value: gainControl];
TeleLoad.WriteWord[h: lark.h, addr: vcbAddr + offsetLastEnergy, value: 0];
TeleLoad.WriteWord[h: lark.h, addr: vcbAddr + offsetDecayTime, value: decayTime];
FOR i:
NAT
IN [0..5)
DO
TeleLoad.WriteWord[h: lark.h, addr: vcbAddr + offsetGainTable + (i * 2), value: gainTable[i]];
ENDLOOP;
TeleLoad.FlushWrites[lark.h];
TeleLoad.SetCacheSize[lark.h, 0];
EXITS
BadArgs => RETURN[BadArgsRope];
BadComm => RETURN[BadCommRope];
};
This command requires entries in a file of the form symbolName offset value even though the value field is ignored.
DspStatics: LarkWork.LarkWorkProc = {
ENABLE {
Convert.Error => GOTO BadArgs;
TeleLoad.Failed => GOTO BadComm;
};
out: IO.STREAM ← lark.h.log;
pl: LIST OF LarkPrograms.PatchItem;
pll: LIST OF LarkPrograms.PatchItem;
TeleLoad.ResetCache[lark.h];
IF argv.argc # 2 THEN GOTO BadArgs;
pll ← LarkPrograms.PatchFromFile[program: lark.program, fileName: argv[1], log: out];
IF pll = NIL THEN RETURN[NIL];
UNTIL pll =
NIL
DO
-- reverse the list
pl ← CONS[pll.first, pl];
pll ← pll.rest;
ENDLOOP;
WHILE pl #
NIL
DO
pl.first.wordValue ← TeleLoad.ReadWord[h: lark.h, addr: pl.first.address];
out.PutF["%-15g: %04xH (%d d)\n", IO.rope[pl.first.name], IO.card[pl.first.wordValue], IO.int[pl.first.wordValue]];
pl ← pl.rest;
ENDLOOP;
EXITS
BadArgs => RETURN[BadArgsRope];
BadComm => RETURN[BadCommRope];
};
ZeroStatics: LarkWork.LarkWorkProc = {
ENABLE {
Convert.Error => GOTO BadArgs;
TeleLoad.Failed => GOTO BadComm;
};
out: IO.STREAM ← lark.h.log;
pl: LIST OF LarkPrograms.PatchItem;
IF argv.argc # 2 THEN GOTO BadArgs;
pl ← LarkPrograms.PatchFromFile[program: lark.program, fileName: argv[1], log: out];
IF pl = NIL THEN RETURN[NIL];
TeleLoad.FlushWrites[lark.h];
TeleLoad.SetCacheSize[lark.h, 2];
WHILE pl #
NIL
DO
TeleLoad.WriteWord[h: lark.h, addr: pl.first.address, value: 0];
out.PutF["%g "];
pl ← pl.rest;
ENDLOOP;
TeleLoad.FlushWrites[lark.h];
TeleLoad.SetCacheSize[lark.h, 0];
out.PutChar['\n];
EXITS
BadArgs => RETURN[BadArgsRope];
BadComm => RETURN[BadCommRope];
};
DspAnalog: LarkWork.LarkWorkProc = {
ENABLE {
TeleLoad.Failed => GOTO BadComm;
};
out: IO.STREAM ← lark.h.log;
xbarState: ARRAY [0..7] OF CARDINAL;
rowBits: ARRAY [0..7] OF CARDINAL = [1, 2, 4, 8, 16, 32, 64, 128];
sources: ARRAY [0..7] OF Rope.ROPE = ["Codec1", "Teleset", "TeleWall", "Mike", "Silence", "Codec2", "Line1", "Line2"];
sinks: ARRAY [0..7] OF Rope.ROPE = ["Codec1", "Teleset", "TeleWall", "Speaker", "DTMF", "Codec2", "Line1", "Line2"];
xbItem: LarkPrograms.STObject;
pioState: ARRAY [0..5] OF CARDINAL;
pioItem: LarkPrograms.STObject;
inAnItem: LarkPrograms.STObject;
inAn: CARDINAL;
found: BOOL;
ipioa: NAT = 0;
ipiob: NAT = 1;
ipioc: NAT = 2;
iapioa: NAT = 3;
iapiob: NAT = 4;
iapioc: NAT = 5;
AISwitch: NAT = 2;
AIRing: NAT = 4;
AIHookSwitch: NAT = 8;
GetBit:
PROC [row, col:
NAT]
RETURNS [
BOOL] = {
RETURN [LOOPHOLE[Basics.BITAND[rowBits[row], xbarState[col]], CARDINAL] # 0];
};
PIOOn:
PROC [bit, byte:
NAT]
RETURNS [
BOOL] = {
RETURN [LOOPHOLE[Basics.BITAND[bit, pioState[byte]], CARDINAL] # 0];
};
PIOOff:
PROC [bit, byte:
NAT]
RETURNS [
BOOL] = {
RETURN [LOOPHOLE[Basics.BITAND[bit, pioState[byte]], CARDINAL] = 0];
};
TeleLoad.ResetCache[lark.h];
[item: xbItem, found: found] ← LarkPrograms.FindVariable[lark.program, "xBarState"];
IF NOT found THEN RETURN["Can't find symbol xBarState"];
FOR i:
NAT
IN [0..7]
DO
xbarState[i] ← TeleLoad.Read[h: lark.h, addr: xbItem.addr + i];
ENDLOOP;
xbarState is indexed by column
FOR row:
NAT
IN [0..7]
DO
found ← FALSE;
FOR col:
NAT
IN [0..7]
DO
IF GetBit[row, col] THEN found ← TRUE;
ENDLOOP;
IF NOT found THEN LOOP;
out.PutRope[sources[row]];
FOR col:
NAT
IN [0..7]
DO
IF GetBit[row, col] THEN out.PutF[" -> %g ", IO.rope[sinks[col]]];
ENDLOOP;
out.PutChar['\n];
ENDLOOP;
[item: pioItem, found: found] ← LarkPrograms.FindVariable[lark.program, "vpio"];
IF NOT found THEN RETURN["Can't find symbol vpio"];
FOR i:
NAT
IN [0..5]
DO
pioState[i] ← TeleLoad.Read[h: lark.h, addr: pioItem.addr + i];
ENDLOOP;
out.PutRope["Relay Status: "];
out.PutRope[IF PIOOn[080H, iapioa] THEN "Reverted " ELSE "Not Reverted "];
out.PutRope[IF PIOOn[020H, ipioc] THEN "RevertHS " ELSE "Not RevertHS "];
out.PutRope[IF PIOOff[040H, iapioa] THEN "OffHook " ELSE "OnHook "];
out.PutRope[IF PIOOff[010H, ipioc] THEN "ARelay on " ELSE "ARelay off "];
out.PutRope["\nOutput devices: \n"];
out.PutRope[IF PIOOff[004H, iapioc] THEN "SideTone on " ELSE "SideTone off "];
out.PutRope[IF PIOOff[008H, iapioc] THEN "RingEnable on " ELSE "RingEnable off "];
out.PutRope[IF PIOOff[040H, ipioa] THEN "LED on " ELSE "LED off "];
[item: inAnItem, found: found] ← LarkPrograms.FindVariable[lark.program, "inAn"];
IF NOT found THEN RETURN["Can't find symbol inAn"];
inAn ← TeleLoad.ReadWord[h: lark.h, addr: inAnItem.addr];
out.PutRope["\nInput devices: "];
out.PutRope[IF LOOPHOLE[Basics.BITAND[inAn, AISwitch], CARDINAL] # 0 THEN "Switch on " ELSE "Switch off "];
out.PutRope[IF LOOPHOLE[Basics.BITAND[inAn, AIRing], CARDINAL] # 0 THEN "Ring on " ELSE "Ring off "];
out.PutRope[IF LOOPHOLE[Basics.BITAND[inAn, AIHookSwitch], CARDINAL] # 0 THEN "HookSwitch on " ELSE "HookSwitch off "];
out.PutChar['\n];
EXITS
BadComm => RETURN[BadCommRope];
};
DspQueue: LarkWork.LarkWorkProc = {
ENABLE {
Convert.Error => GOTO BadArgs;
TeleLoad.Failed => GOTO BadComm;
};
out: IO.STREAM ← lark.h.log;
queue: Queue;
queueAddress: TeleLoad.CoreAddress;
queueAddressSymbol: LarkPrograms.STObject;
found: BOOL;
maxLength: NAT;
TeleLoad.ResetCache[lark.h];
IF argv.argc < 2 THEN GOTO BadArgs;
First try to interpret the argument as a symbol
[queueAddressSymbol, found] ← LarkPrograms.FindVariable[lark.program, argv[1]];
IF NOT found THEN RETURN["Queue name not found"];
queueAddress ← queueAddressSymbol.addr;
IF argv.argc > 2 THEN maxLength ← Basics.LowHalf[Convert.CardFromRope[argv[2]]] ELSE maxLength ← 20;
queue.head ← TeleLoad.ReadWord[lark.h, queueAddress];
queue.tail ← TeleLoad.ReadWord[lark.h, queueAddress + 2];
PrintQueue[lark: lark, out: out, q: queue, max: maxLength];
out.PutChar['\n];
EXITS
BadArgs => RETURN[BadArgsRope];
BadComm => RETURN[BadCommRope];
};
DspList: LarkWork.LarkWorkProc = {
ENABLE {
Convert.Error => GOTO BadArgs;
TeleLoad.Failed => GOTO BadComm;
};
out: IO.STREAM ← lark.h.log;
queue: Queue;
queueAddressSymbol: LarkPrograms.STObject;
maxLength: NAT;
found: BOOL;
TeleLoad.ResetCache[lark.h];
IF argv.argc < 2 THEN GOTO BadArgs;
[queueAddressSymbol, found] ← LarkPrograms.FindVariable[lark.program, argv[1]];
IF NOT found THEN RETURN["List name not found"];
queue.head ← queueAddressSymbol.addr;
queue.tail ← 0;
IF argv.argc > 2 THEN maxLength ← Basics.LowHalf[Convert.CardFromRope[argv[2]]] ELSE maxLength ← 20;
PrintQueue[lark: lark, out: out, q: queue, max: maxLength, printTail: FALSE];
out.PutChar['\n];
EXITS
BadArgs => RETURN[BadArgsRope];
BadComm => RETURN[BadCommRope];
};
Register all the commands
LarkWork.RegisterLarkWorkProc[proc: DspVCB, key: ".DspVCB", caseMatters: FALSE, doc: "Print a voice command block", usage: ".DspVCB {vcb}"];
LarkWork.RegisterLarkWorkProc[proc: DspStatics, key: ".dstat", caseMatters: FALSE, doc: "Display statics listed in a file", usage: ".ds fileName"];
LarkWork.RegisterLarkWorkProc[proc: ZeroStatics, key: ".zstat", caseMatters: FALSE, doc: "Zero statics listed in a file", usage: ".zs fileName"];
LarkWork.RegisterLarkWorkProc[proc: DspAnalog, key: ".DspAnalog", caseMatters: FALSE, doc: "Display analog status", usage: ".DspAnalog"];
LarkWork.RegisterLarkWorkProc[proc: ESSet, key: ".ESSet", caseMatters: FALSE, doc: "Set Echo Suppression parameters", usage: ".ESSet VCB controlledVCB decayTime gt[0] gt[1] gt[2] gt[3] gt[4]"];
LarkWork.RegisterLarkWorkProc[proc: DspQueue, key: ".DspQueue", caseMatters: FALSE, doc: "Print a queue", usage: ".DspQueue queueAddress {max length (20)}"];
LarkWork.RegisterLarkWorkProc[proc: DspList, key: ".DspList", caseMatters: FALSE, doc: "Print a list", usage: ".DspList firstElement {max length (20)}"];
END.
May 3, 1983 6:21 pm, LCS, created
December 22, 1983 2:49 pm, LCS, Cedar 5