[Indigo]<Voice>Thrush>ThSmartsPrivate.mesa!36

ThSmartsPrivate.mesa

Last modified by D. Swinehart, August 6, 1985 3:50:34 pm PDT

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, LarkModel, o3i1, StatusEvent, ToneSpec, ts0 ],

LarkPlay USING [ ToneList, ToneSpec ],

LarkRpcControl USING [ InterfaceRecord ],

Rope USING [ROPE],

BasicTime USING [ GMT ],

Thrush USING [

ConversationHandle, ConvEvent, ConvEventBody, Disposition, IntervalSpecs, IntID, NetAddress, nullHandle, nullConvHandle, nullIntID, PartyHandle, ProseSpec, ProseSpecs, Reason, ROPE, SHHH, SmartsHandle, StateInConv, Tune, VoiceDirection, VoiceInterval ],

ThPartyPrivate USING [ SmartsData ],

ThSmartsRpcControl USING [ InterfaceRecord ]

;

ThSmartsPrivate: CEDAR DEFINITIONS = {

Copies

ConversationHandle: TYPE = Thrush.ConversationHandle;

nullConvHandle: ConversationHandle = Thrush.nullConvHandle;

PartyHandle: TYPE = Thrush.PartyHandle;

Reason: TYPE = Thrush.Reason;

ROPE: TYPE = Thrush.ROPE;

SHHH: TYPE = Thrush.SHHH;

SmartsData: TYPE = ThPartyPrivate.SmartsData;

SmartsHandle: TYPE = Thrush.SmartsHandle;

StatusEvent: TYPE = Lark.StatusEvent;

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, ring1, between, ring };

no ring, glitch interval, first (partial?) ring, break, nth ring

RingMode: TYPE = { -- <<obsolete??>>

internal, -- standard ringing cadence

trunk -- distinctive ringing for incoming back door calls

};

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

[

smarts: SmartsData, -- back pointer to my smarts.

otherSmarts: SmartsData←NIL, -- trunk or station smarts, depending on which this is.

larkInfo: LarkInfo,

State of Lark hardware, shared between Lark and Trunk

conversations: OpenConversations←NIL,

currentConvID: ConversationHandle←nullConvHandle, -- the one we're dealing with.

thProcess: PROCESS←NIL, -- the process that manages Lark smarts

thAction: CONDITION, -- poke this when something has happened.

apprise: BOOL←FALSE, -- needs to be true before waking to thAction has any meaning.

Parsing control fields

ParseEvent: PROC[smartsInfo: SmartsInfo, sEvent: 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

Supervise: PROC[info: SmartsInfo],

Command procedure to act on results of completely parsed command

lastTouchpadChar: Lark.Event ← '\000,

parseState: ParseState ← idle,

Independent of any notion of what's going on in eventInfo; desire of local user

arguments: ROPE←NIL,

argLength: NAT𡤀,

offset: NAT𡤀, -- kludge allowing more than ten touchpad commands

haveArguments, cmdOrRecip, haveOne: BOOLEAN←FALSE,

LarkTrunkSmarts fields; something feels pretty wrong here.

phoneNumber: Rope.ROPE←NIL -- signalling information for TelCo.

];

OpenConversations: TYPE = LIST OF ConvDesc;

ConvDesc: TYPE = REF ConvDescBody;

ConvDescBody: TYPE = RECORD [

cState: Thrush.ConvEventBody, -- amalgam of useful info from reported events

desiredState: Thrush.StateInConv𡤊ny, -- what we're aiming for

desiredPartyID: PartyHandle←NULL,

desiredReason: Reason←wontSay,

desiredComment: ROPE←NIL,

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: BOOL ←FALSE,

newEvent: BOOL←FALSE,

signallingStarted: BOOL←FALSE,

descValid: BOOL←FALSE

];

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 --

netAddress: Thrush.NetAddress, -- <<needed when creating socket numbers?>> --

model: Lark.LarkModel, -- what does this Lark look like? --

debugIn: IO.STREAM, debugPrint: IO.STREAM←NIL,

larkState: LarkState ← none, -- tone/crossbar/connect state of actual Lark hardware

newActions: LIST OF REF←NIL, -- queue of low-level requests to supervisor process

lastAction: LIST OF REF←NIL, -- used in request-queue maintenance,

larkProcess: PROCESS←NIL, -- maintains same

stateChange: CONDITION, -- larkProcess should notice change

hookState: HookState ← onhook, -- state of switchhook/speakerphone switch...

terminalType: TerminalType ← std, -- telset, speakerphone, or monitor switching.

Special attributes. << Not clear how set >>

autoAnswer: BOOL←FALSE, -- answers when called.

radio: BOOL←FALSE, -- used with hotline; connects line in instead of telset when called.

monitor: BOOL←FALSE, -- speaker repeats telset receiver in telset mode.

textToSpeech: BOOL←FALSE, -- Prose 2000 synthesizer is available on this Lark.

Some values that have to be preserved from one larkState to another

forwardedCall: BOOL←FALSE,

spec: Lark.ConnectionSpec←NIL,

toneSpec: LarkPlay.ToneSpec←NIL,

nextToneList: LIST OF LarkPlay.ToneList←NIL,

larkToneSpec: Lark.ToneSpec←NIL,

Prose control values

proseResponse: ROPE←NIL, -- holds incomplete Prose responses

flushJustFinished: BOOL←FALSE, -- 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←NIL,

clientMarker: INT←maxClientMarker,

controlMarker: INT←maxControlMarker,

ctrlMarkerQueue: LIST OF REF ANY←NIL, -- holds queue of control markers

pktsOutstanding: INT𡤀,

flushInProgress: BOOL←FALSE, -- consider combining w flushJustFinished?

Click and ring detect timings

swOnTime: CARDINAL𡤀,

ringChangeTime: CARDINAL𡤀,

ringDetState: RingDetState ← idle,

ringDetWaitState: RingDetState←idle,

ringDetCondition: CONDITION,

ringDetInstance: CARDINAL𡤀, -- paranoia

Ringing control information

ringMode: RingMode ← internal, -- what kind of ringing should we do next time? <<Obsolete??>>

ringTune: LarkPlay.ToneSpec, -- Specification of ring tune

ringingTune: LarkPlay.ToneSpec, -- Specification of ringback tune

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

];

LarkStateSpec: TYPE = RECORD [

state: LarkState,

sInfo: SmartsInfo ];

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, sInfo: SmartsInfo, data: REF←NIL ];

INTERNAL version

EnterLarkSt: PROC

[ info: LarkInfo, newState: LarkState, sInfo: SmartsInfo, data: REF←NIL ];

INTERNAL version

TonesDone: PROC[ info: LarkInfo, commandEvent: Lark.StatusEvent, sInfo: SmartsInfo ];

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, sInfo: SmartsInfo];

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: BOOL←TRUE ];

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[ hostPartyID: Thrush.PartyHandle,

hostSmarts: ThPartyPrivate.SmartsData, hostInfo: SmartsInfo ]

RETURNS [ smartsID: Thrush.SmartsHandle ];

EnableSmarts: PROC[info: SmartsInfo] RETURNS[enabled: BOOL];

Deregister: PROC[info: SmartsInfo ];

LarkParseEvent: -- INTERNAL -- PROC[smartsInfo: SmartsInfo, sEvent: StatusEvent];

LarkProgress: PROC[

interface: ThSmartsRpcControl.InterfaceRecord,

shh: SHHH,

smartsID: Thrush.SmartsHandle,

event: Thrush.ConvEvent,

yourParty: BOOL,

latestEvent: BOOL,

informationOnly: BOOL

] RETURNS [ d: Thrush.Disposition ];

LarkSupervise: PROC[info: SmartsInfo];

LarkSetInterval: PROC[

shh: SHHH,

smartsID: SmartsHandle,

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: SmartsHandle←Thrush.nullHandle,

smarts: ThPartyPrivate.SmartsData←NIL]

RETURNS [info: SmartsInfo];

GetSIC: PROC[info: SmartsInfo] RETURNS [ state: Thrush.StateInConv ];

Apprise: PROC[info: SmartsInfo];

ChangeState: PROC[

info: SmartsInfo,

cDesc: ConvDesc,

state: Thrush.StateInConv ← idle,

reason: Reason ← wontSay,

comment: ROPE←NIL

];

GetConvDesc: PROC[info: SmartsInfo] RETURNS [ cDesc: ConvDesc←NIL ];

GetConv: PROC[info: SmartsInfo, convID: ConversationHandle, validIfNew: BOOL]

RETURNS [ cDesc: ConvDesc←NIL ];

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