ThSmartsPrivate.mesa
Copyright © 1985 by Xerox Corporation. All rights reserved.
Last modified by D. Swinehart, December 8, 1985 2:52:08 pm PST
Polle Zellweger (PTZ) August 29, 1985 5:35:30 pm PDT
Last Edited by: Pier, May 3, 1984 1:04:49 pm PDT
DIRECTORY
IO USING [ STREAM ],
Lark USING [
CommandEvents, ConnectionSpec, disabled, enabled, Event, KeyTable, LarkModel, o3i1, StatusEvent, ToneSpec, ts0 ],
LarkPlay USING [ ToneList, ToneSpec ],
LarkRpcControl USING [ InterfaceRecord ],
MBQueue USING [ Queue ],
Rope USING [ROPE],
BasicTime USING [ GMT ],
Thrush USING [
ConversationID, ConvEvent, ConvEventBody, NB, NetAddress, nullID, nullConvID, PartyID, ProseSpec, ProseSpecs, Reason, ROPE, SHHH, SmartsID, StateInConv ],
ThParty USING [ PartyInfo ],
ThPartyPrivate USING [ SmartsData ],
ThSmartsRpcControl USING [ InterfaceRecord ]
;
ThSmartsPrivate: CEDAR DEFINITIONS = {
Copies
SHHH: TYPE = Thrush.SHHH;
SmartsData: TYPE = ThPartyPrivate.SmartsData;
Types
States (enumerated types) and other scalars
Parser is controlled by state sequence that's largely independent of the state of the smarts in any conversation. Parser represents the user's wishes. After parsing is complete, other processing determines whether these wishes can be granted.
ParseState: TYPE = {
idle, getStr, getSeq, getFeep, getNum, inStr, inSeq, inFeep, inNum, inTossStr };
This state is essentially a superset of Thrush.StateInConv. It is used to express the user's wishes; when wish and reality coincide, it is set to the corresponding StateInConv, and quiescence follows, at least temporarily.
Control of the Lark hardware state (remaining types)
LarkState: TYPE = {
none,     -- Initial state
idle,     -- Phone not in use
talking,    -- Etherphone conversation in progress
trunkSignalling,  -- "Feeping"
trunkTalking,  -- Standard telephone conversation in progress
trunkForwarding, -- Like trunkTalking, but call is forwarded to some other Lark
trunkFlashing,  -- Implementing special switchhook flash
failed,    -- This Lark has died and its brain is dying, too.
recovering,   -- Lark is presumed not to work, but use attempts don't raise ERRORS
ringing,    -- Ringing loudly through Lark speaker
silence,    -- Dial tone has been broken, dialing in progress.
dialTone,    -- Caller hears dial tone.
ringBack,    -- Caller hears ringing.
busyTone,   -- Caller hears busy signal.
errorTone    -- Caller hears fast busy signal.
};
ProgressTones: TYPE = LarkState[dialTone..errorTone];
HookState: TYPE = { onhook, telset, spkr, sPkr, spKr, both, bOth, monitor };
TerminalType: TYPE = {std, spkr, monitor, radio};
RingDetState: TYPE = { idle, maybe, ring, between };
no ring, glitch interval, in-a-ring, break
Orig: TYPE = { unknown, us, them };
click: Lark.Event = Lark.ts0; -- Momentary closure of speaker box switch.
LSwitches: TYPE = {
xBarAll, hook, aSwitch, sideTone, ringO, revert, revertHook, led, spMode, none };
LState: TYPE = RECORD [
voiceMode: Lark.Event←Lark.o3i1,
echoStyle: [0..3]𡤀,
xbar: PACKED ARRAY[0..8) OF [0..256) ← ALL[0],
lSw: ARRAY LSwitches OF Lark.Event ← ALL[Lark.disabled]
];
Structures
Information used by LarkSmarts and LarkTrunkSmarts implementations
They require similar information, although the trunk does not use all of it.
SmartsInfo: TYPE = REF SmartsInfoBody;
SmartsInfoBody: TYPE = MONITORED RECORD
[
smartsID: Thrush.SmartsID, -- back pointer to my smarts.
otherSmartsID: Thrush.SmartsID←Thrush.nullID,
Trunk or station smarts, depending on which this is.
larkInfo: LarkInfo,
State of Lark hardware, shared between Lark and Trunk
conversations: OpenConversations←NIL,
currentConvID: Thrush.ConversationID←Thrush.nullConvID, -- the one we're dealing with.
requests: MBQueue.Queue←NIL, -- serialize progress reports, requests for actions
Parsing control fields
ParseEvent: PROC[smartsInfo: SmartsInfo, sEvent: Lark.StatusEvent],
Allows Lark, Lark trunk, Radio, ... smarts to parse different command languages
Command: PROC[info: SmartsInfo, val: INT𡤀]←NIL,
Command procedure to act on results of completely parsed command
NoteNewStateP: PROC[cDesc: ConvDesc, convEvent: Thrush.ConvEvent]←NIL,
Procedure to update conversation description based on event: smarts-specific
lastTouchpadChar: Lark.Event ← '\000,
parseState: ParseState ← $idle,
Independent of any notion of what's going on in eventInfo; desire of local user
arguments: Rope.ROPENIL,
argLength: NAT𡤀,
offset: NAT𡤀, -- kludge allowing more than ten touchpad commands
haveArguments, cmdOrRecip, haveOne: BOOLEANFALSE
];
OpenConversations: TYPE = LIST OF ConvDesc;
ConvDesc: TYPE = REF ConvDescBody;
ConvDescBody: TYPE = RECORD [
info: SmartsInfo,        -- corresponding to credentials.smartsID (or else!)
situation: Thrush.ConvEventBody,   -- .self describes current state in conv.
keyTable: Lark.KeyTable ← NIL
];
Temporarily out of service -- please use the circular stairway
newIntervals: Thrush.IntervalSpecs ← NIL,
iTail: Thrush.IntervalSpecs ← NIL,
desiredIntID: Thrush.IntID ← Thrush.nullIntID,
newProses: Thrush.ProseSpecs ← NIL,
pTail: Thrush.ProseSpecs ← NIL,
desiredProseID: Thrush.IntID ← Thrush.nullIntID,
originator: Orig ← $unknown,
newSpec, newKeys, newAddress: BOOLFALSE,
newEvent: BOOLFALSE,
signallingStarted: BOOLFALSE,
ConvRequest: TYPE = REF ConvRequestBody;
ConvRequestBody: TYPE = RECORD [
cDesc: ConvDesc, -- present state,
desiredSituation: Thrush.ConvEventBody ← []
];
TrunkBundle: TYPE= RECORD [
spec: ThParty.PartyInfo, -- connection specifications
ropeSpec: Rope.ROPE
];
Access to the Lark hardware via the Lark interface. This monitored record is shared by the Smarts info for both the LarkSmarts and LarkTrunkSmarts. There are also some random shared fields kept here.
LarkInfo: TYPE = REF LarkInfoBody;
LarkInfoBody: TYPE = MONITORED RECORD
[
interface: LarkRpcControl.InterfaceRecord, -- here's how you make calls to Lark --
shh: SHHH, -- here's what you use to encrypt them --
larkSmartsInfo: SmartsInfo,  -- back pointers
larkTrunkSmartsInfo: SmartsInfo,  -- back pointers
netAddress: Thrush.NetAddress, -- <<needed when creating socket numbers?>> --
model: Lark.LarkModel, -- what does this Lark look like? --
debugIn: IO.STREAM, debugPrint: IO.STREAMNIL,
larkState: LarkState ← $none,  -- tone/crossbar/connect state of actual Lark hardware
newActions: LIST OF REFNIL, -- queue of low-level requests to supervisor process
lastAction: LIST OF REFNIL, -- used in request-queue maintenance,
larkProcess: PROCESSNIL, -- maintains same
stateChange: CONDITION,  -- larkProcess should notice change
hookState: HookState ← $onhook, -- state of switchhook/speakerphone switch...
terminalType: TerminalType ← $std, -- telset, speakerphone, or monitor switching.
textToSpeech: BOOLFALSE,-- Prose 2000 synthesizer is available on this Lark.
Some values that have to be preserved from one larkState to another
forwardedCall: BOOLFALSE,
spec: ThParty.PartyInfo←NIL,
cSpec: Lark.ConnectionSpec←NIL,
keyTable: Lark.KeyTable ← NIL,
toneSpec: LarkPlay.ToneSpec←NIL,
nextToneList: LIST OF LarkPlay.ToneList←NIL,
larkToneSpec: Lark.ToneSpec←NIL,
Prose control values
proseResponse: Rope.ROPENIL, -- holds incomplete Prose responses
flushJustFinished: BOOLFALSE, -- can expect to have to flush proseQueue next time thru LarkInImpl.HandleProseOutput
proseQueue: LarkProseQueue←NIL, -- holds queue of client markers and proseSpecs
pTail: LarkProseQueue←NIL,
textToSpeak: Rope.ROPENIL,
clientMarker: INT←maxClientMarker,
controlMarker: INT←maxControlMarker,
ctrlMarkerQueue: LIST OF REF ANYNIL, -- holds queue of control markers
pktsOutstanding: INT𡤀,
flushInProgress: BOOLFALSE, -- consider combining w flushJustFinished?
Click and ring detect timings
swOnTime: CARDINAL𡤀,
Lark reports the time when a ringing voltage is detected on the telewall, and the time when the voltage goes away. There can be an on-off glitch when the phone is hung up, and ringing is an alternating thing, so we need to interpret these signals before passing on to higher levels. See LarkInImpl.
ringChangeTime: CARDINAL𡤀,
ringDetState: RingDetState ← $idle,
ringDetCondition: CONDITION,
ringDetInstance: INT𡤀, -- timeout routine is relevant only if this matches
Ringing control information
When a Note in a tune specifies "notify", expectedNotification is incremented (mod the lower-case letters) and sent along to the Lark. When the Lark finishes that note, it notifies the smarts, and eventually LarkOut, using that value. It's possible (though not desired) for this notification to precede the "WAIT" that pends notification. In this case, we mustn't wait. See LarkOutImpl.DoTones and ditto.WaitQ. receivedNotification is set to a value outside the range just after each WAIT opportunity terminates.
expectedNotification: Lark.Event ← 'z,
receivedNotification: Lark.Event ← 'Y,
LarkSupervisor Variables
lastTerminalType: TerminalType ← $std,
lState: LState ← [lSw: ALL[Lark.enabled]],
scratchEv: Lark.CommandEvents ← NIL
];
LarkProseQueue: TYPE = LIST OF LarkProseSpecBody;
LarkProseSpecBody: TYPE = RECORD [
proseSpec: Thrush.ProseSpec←NIL,
proseMarker: INT𡤀
];
ProseCmd: TYPE = Rope.ROPE;
indexMarkerEnd: CHAR = 'i;
maxClientMarker: INT = 199;
maxControlMarker: INT = 250;
pReset: ProseCmd; -- = "\022" (ControlR)
pResetConfirmEnd: CHAR = 'R;
stopAndFlush: ProseCmd; -- = "\033[S" (\033 is ESC)
stopAndFlushEnd: CHAR = 'S;
flushMarker: INT = 1000;
proseFailure: INT = 1001;
Procedures
ENTRY version
EnterLarkState: PROC
[ info: LarkInfo, newState: LarkState, data: REFNIL ];
Put this lark into the indicated state, setting tones, crossbar, ethernet connections, whatever else is appropriate to the state. By this point, the higher levels are supposed to have sorted out any conflicts between the requirements of the two Smarts (Lark and LarkTrunk) that control the Lark. A single state may not be enough to do that, in the long run.
Data (at this writing) can be a Party.PartyInfo (containing connection specifications), a Lark.KeyTable, a LarkPlay.toneSpec, a Thrush.ProseSpecs, or a ROPE. The KeyTable should be accepted and forwarded on to the Lark whenever it appears, while the others will be interpreted relative to newState.
INTERNAL version
EnterLarkSt: PROC
[ info: LarkInfo, newState: LarkState, data: REFNIL ];
INTERNAL version
TonesDone: PROC[ info: LarkInfo, commandEvent: Lark.StatusEvent ];
A way to feed back tone completions, initiated by LarkOut, back to LarkOut.
Feep tones don't go through this path, since higher-levels need to know about the situation.
QueueFeeps: PROC
[ sInfo: SmartsInfo, feeps: Thrush.ProseSpecs ];
ProseControlDone: PROC[info: LarkInfo, marker: INT];
Reports low-level control marker completion from Prose (thru LarkInImpl) to LarkOutImpl, to trigger sending more text if there is any. For Prose metering only (to avoid filling Lark and Prose buffers).
ReportProseDone: PROC[info: SmartsInfo, proseSpec: Thrush.ProseSpec];
Reports client-level marker completion from Prose (thru LarkInImpl) to party level, for conversation mgmt and client completion reports. Corresponds to the end of a Finch client SpeakText command.
InterpretHookState: PROC
[ info: LarkInfo, rawEvent: Lark.StatusEvent, sInfo: SmartsInfo ]
RETURNS [ processedEvent: Lark.StatusEvent ];
CheckHookState: PROC
[ info: LarkInfo]
RETURNS [ onHook: BOOLTRUE ];
Determines if user terminal appears to be offhook. May not be able to tell if there's
a "click-mode" speakerphone call in progress.
Registration of Lark trunks (back doors)
RegisterTrunk: PROC[
hostSmartsID: Thrush.SmartsID, hostInfo: SmartsInfo, partyRname: Thrush.ROPE ]
RETURNS [ nb: Thrush.NB, smartsID: Thrush.SmartsID ];
EnableSmarts: PROC[info: SmartsInfo] RETURNS[enabled: BOOL];
Deregister: PROC[smartsID: Thrush.SmartsID];
LarkParseEvent: -- INTERNAL -- PROC[smartsInfo: SmartsInfo, sEvent: Lark.StatusEvent];
NoteNewState: PROC[cDesc: ConvDesc, convEvent: Thrush.ConvEvent];
ComputeConnection: PROC[cDesc: ConvDesc] RETURNS [pInfo: ThParty.PartyInfo ← NIL];
LarkProgress: PROC[
interface: ThSmartsRpcControl.InterfaceRecord,
shh: SHHH,
convEvent: Thrush.ConvEvent
];
LarkSetInterval: PROC[
shh: SHHH,
smartsID: Thrush.SmartsID,
tune: Thrush.Tune,
interval: Thrush.VoiceInterval,
direction: Thrush.VoiceDirection,
queueIt: BOOLEAN
] RETURNS [ d: Thrush.Disposition, u: Thrush.Tune ];
LarkFailed: ERROR[sInfo: SmartsInfo];
Return current state
GetSmartsInfo: PROC[smartsID: Thrush.SmartsID] RETURNS [info: SmartsInfo];
GetSIC: PROC[info: SmartsInfo] RETURNS [ state: Thrush.StateInConv ];
ChangeState: PROC[
cDesc: ConvDesc,
state: Thrush.StateInConv ← $idle,
reason: Thrush.Reason ← NIL, -- $wontSay
comment: Thrush.ROPENIL
] RETURNS [nb: Thrush.NB]; -- advisory only, by this point
AssessDamage: PROC [nb: Thrush.NB, cDesc: ConvDesc, convEvent: Thrush.ConvEvent];
ForgetConv: PROC[cDesc: ConvDesc];
GetConvDesc: PROC[info: SmartsInfo] RETURNS [ cDesc: ConvDesc←NIL ];
GetConv: PROC[info: SmartsInfo, convID: Thrush.ConversationID, createOK: BOOLFALSE]
RETURNS [ cDesc: ConvDesc ];
DBInfo: PROC[partyID: Thrush.PartyID, attribute: ATOMNIL]
RETURNS [ dbRname: Rope.ROPE, dbAtom: ATOM, value: Rope.ROPE ];
Converts from "Sturgis.pa" to "Sturgis.pa.lark", produces $sturgis.pa as well, and if attribute is given, value ← the selected attribute for "Sturgis.pa.lark" in the GV database
}.
Swinehart, May 21, 1985 4:39:39 pm PDT
Cedar 6.0, adding Text-to-speech service
changes to: LarkInfoBody
Polle Zellweger (PTZ) August 8, 1985 8:11:29 pm PDT
changes to: pResetConfirmEnd, stopAndFlushEnd, incorrectClientMarker, flushMarker
Polle Zellweger (PTZ) August 19, 1985 2:52:15 pm PDT
Handle Prose flushing.
changes to: pResetConfirmEnd, stopAndFlushEnd, incorrectClientMarker, flushMarker, LarkInfoBody (added flushJustFinished)
Polle Zellweger (PTZ) August 20, 1985 7:50:19 pm PDT
changes to: ResetProse, ProseControlDone, ReportProseDone
Polle Zellweger (PTZ) August 29, 1985 5:31:56 pm PDT
Place local variables from LarkOutImpl.LarkSupervisor into LarkInfo record.
changes to: LarkInfoBody, maxClientMarker, indexMarkerEnd, maxControlMarker, pReset, pResetConfirmEnd, stopAndFlush, stopAndFlushEnd, flushMarker, proseFailure
Swinehart, October 25, 1985 6:00:46 pm PDT
Handle => ID
changes to: DIRECTORY, ConversationID, PartyID, SmartsID, SmartsInfoBody, ConvDescBody, LarkInfoBody, RegisterTrunk, LarkProgress, LarkSetInterval, GetSmartsInfo, GetConv