DIRECTORY
IO,
Commander USING [ CommandProc, Register ],
Lark USING [ bStar, bThorp, CommandEvent, CommandEvents, CommandEventSequence, Device, disabled, DTMFEvent, enabled, endNum, Event, Passel, reset, StatusEvent, StatusEvents, SHHH ],
LarkSmarts,
Log USING [ ProblemBool, Report, SLOG ],
Nice,
RPC USING [ CallFailed ], 
Rope USING [ ROPE ],
Process USING [ Detach, MsecToTicks, SetTimeout, Ticks ],
ThPartyPrivate USING [ SmartsData ],
ThSmartsPrivate USING [
click, EnterLarkSt, GetSmartsInfo, HookState, LarkInfo, LarkState, RingDetState, SmartsInfo, TerminalType, TonesDone ],
Thrush USING[ H, pERROR, ROPE, SHHH, SmartsHandle, ThHandle ],
ThNet USING [ pd ]
;

LarkInImpl: CEDAR MONITOR LOCKS info USING info: LarkInfo
IMPORTS
Commander, IO, Log, Nice, Process, RPC, ThNet, Thrush, ThSmartsPrivate
EXPORTS LarkSmarts, ThSmartsPrivate= {
OPEN IO;

H: PROC[r: REF] RETURNS[Thrush.ThHandle] = INLINE {RETURN[Thrush.H[r]]; };
HookState: TYPE = ThSmartsPrivate.HookState;
LarkInfo: TYPE = ThSmartsPrivate.LarkInfo;
RingDetState: TYPE = ThSmartsPrivate.RingDetState;
SmartsData: TYPE = ThPartyPrivate.SmartsData;
SmartsInfo: TYPE = ThSmartsPrivate.SmartsInfo;
SmartsHandle: TYPE = Thrush.SmartsHandle;
TerminalType: TYPE = ThSmartsPrivate.TerminalType;
ROPE: TYPE = Thrush.ROPE;
bStar: Lark.Event = Lark.bStar;
bThorp: Lark.Event = Lark.bThorp;
enabled: Lark.Event = Lark.enabled;
endNum: Lark.Event = Lark.endNum;
disabled: Lark.Event = Lark.disabled;
reset: Lark.Event = Lark.reset;

PD: TYPE = RECORD [
callTimeoutOK: BOOL_FALSE -- set to keep Thrush alive when debugging a Lark.
];
pd: REF PD _ NEW[PD_[]];



DebEvent: PROC[info: SmartsInfo, ev: Lark.StatusEvent] = INLINE {
s: IO.STREAM=IO.ROS[];
s.PutF["[%3B, %3B, ",
card[LONG[
IF info#NIL THEN LOOPHOLE[info.larkInfo.netAddress.host,CARDINAL]
ELSE LOOPHOLE[777B, CARDINAL]]],
card[LONG[LOOPHOLE[ev.device, CARDINAL]]]]; 
IF ev.event<='z THEN s.PutF["%g]  ",char[ev.event]]
ELSE s.PutF["<%3B>]  ", card[LONG[LOOPHOLE[ev.event, CARDINAL]]]];
Log.Report[s.RopeFromROS[], $LarkDetailed, info.larkInfo];
};

crowbar: BOOL_FALSE; -- TRUE to check basic RPC performance from Lark.
RecordEvent: PUBLIC PROC[shh: Thrush.SHHH, smartsID: Thrush.SmartsHandle, whatHappened: Lark.StatusEvents]
RETURNS [ success: BOOL_TRUE ]
= {
smartsInfo: SmartsInfo = ThSmartsPrivate.GetSmartsInfo[smartsID: smartsID];
parseInfo: SmartsInfo _ smartsInfo;
info: LarkInfo;
parseSmarts: SmartsData;
IF smartsInfo=NIL OR (info _ smartsInfo.larkInfo)=NIL THEN RETURN[FALSE];
parseSmarts _ smartsInfo.smarts;
FOR i: Lark.Passel IN [0 .. whatHappened.length) DO
sEvent: Lark.StatusEvent _ whatHappened[i];
IF ThNet.pd.debug THEN DebEvent[smartsInfo, sEvent];
IF crowbar OR info.larkState=failed OR info.larkState=recovering THEN LOOP;
Log.SLOG[];
SELECT sEvent.device FROM
ringDetect => {
parseSmarts _ smartsInfo.otherSmarts;
parseInfo _ ThSmartsPrivate.GetSmartsInfo[smarts: parseSmarts]; };
tones => SELECT sEvent.event FROM
'F=> -- Feeping complete
{
parseSmarts _ smartsInfo.otherSmarts;
parseInfo _ ThSmartsPrivate.GetSmartsInfo[smarts: parseSmarts];
};
ENDCASE; -- Other tones finished
ENDCASE;
SELECT sEvent.device FROM
speakerSwitch => sEvent _ InterpretSpeakerSwitch[info, sEvent];
ringDetect => sEvent _ InterpretRingDetect[info, H[parseSmarts], parseInfo, sEvent];
touchPad => {
IF sEvent.event=disabled THEN sEvent.event _ smartsInfo.lastTouchpadChar
ELSE {
smartsInfo.lastTouchpadChar _ sEvent.event; LOOP; -- down transitions of DTMF pad.
};
IF sEvent.event='\000 THEN LOOP;
};
ENDCASE;
IF sEvent.device=nothing THEN LOOP;
parseInfo.ParseEvent[ smartsInfo: parseInfo, sEvent: sEvent ];
ENDLOOP; };

EventRope: PUBLIC PROC[
shh: Thrush.SHHH, smartsID: SmartsHandle, time: CARDINAL, device: Lark.Device, events: ROPE]
RETURNS[success: BOOL] = {
NULL;
};

InterpretSpeakerSwitch: PROC[info: LarkInfo, sEvent: Lark.StatusEvent]
RETURNS [ processedEvent: Lark.StatusEvent] = --<<INLINE>>-- {
interval: INTEGER = LOOPHOLE[sEvent.time-info.swOnTime];
processedEvent _ sEvent;
SELECT sEvent.event FROM
enabled => info.swOnTime _ sEvent.time;
disabled => NULL;
ENDCASE => ERROR Thrush.pERROR;
IF interval < 0 OR interval > spClickInterval THEN RETURN;
processedEvent.event _ ThSmartsPrivate.click; };

spClickInterval: INTEGER _ 500;

InterpretRingDetect: ENTRY PROC[info: LarkInfo, smartsID: SmartsHandle, smartsInfo: SmartsInfo, sEvent: Lark.StatusEvent]
RETURNS [ processedEvent: Lark.StatusEvent _ [ 0, nothing, Lark.reset ] ] = --<<INLINE>>-- {
ENABLE UNWIND=>NULL;
interval: INTEGER = LOOPHOLE[sEvent.time-info.ringChangeTime];
event: Lark.Event = sEvent.event;
info.ringChangeTime _ sEvent.time;
SELECT event FROM 
enabled => SELECT info.ringDetState FROM idle, between=>NULL; ENDCASE=>RETURN;
disabled => SELECT info.ringDetState FROM idle, between=>RETURN; ENDCASE;
ENDCASE=>RETURN;
SELECT info.ringDetState FROM
idle => TRUSTED { -- known enabled --
info.ringDetState _ maybe;
info.ringDetWaitState_idle;
info.ringDetInstance _ info.ringDetInstance+1;
Process.Detach[FORK RingDetProc[smartsID, smartsInfo, info.ringDetInstance]]; };
maybe =>  { -- known disabled --
IF interval<debounceInterval THEN info.ringDetState_idle ELSE {
info.ringDetState _ between; 
processedEvent _ sEvent; processedEvent.event _ enabled; }; };
ring1 => {  -- known disabled -- 
info.ringDetState _ between; };
ring => { -- known disabled --
info.ringDetState _ IF interval > ringInterval THEN between ELSE idle; };
between => { -- known enabled --
info.ringDetState _ IF interval < breakInterval THEN ring ELSE idle; };
ENDCASE;
IF info.ringDetState#info.ringDetWaitState THEN NOTIFY info.ringDetCondition; };

debounceInterval: INTEGER _ 300; -- ms.
ringInterval: INTEGER = 1700; -- ms., 2 sec. nominal, 300 ms. benefit of doubt
breakInterval: INTEGER = 4500; -- ms., 4 sec. nominal, 500 ms. benefit of doubt
debounceIntTicks: Process.Ticks = Process.MsecToTicks[debounceInterval];
ringIntTicks: Process.Ticks = Process.MsecToTicks[ringInterval];
breakIntTicks: Process.Ticks = Process.MsecToTicks[breakInterval];


RingDetProc: PROC[smartsID: SmartsHandle, smartsInfo: SmartsInfo, instance: CARDINAL] = {
info: LarkInfo = smartsInfo.larkInfo;
event: Lark.Event;
RingDetProcEntry: ENTRY PROC[info: LarkInfo] RETURNS[stillRunning: BOOL]	 = --INLINE-- {
ENABLE UNWIND=>NULL;
newState: RingDetState = IF info.ringDetInstance#instance THEN idle ELSE info.ringDetState;
event _ reset;
IF newState#idle AND newState=info.ringDetWaitState THEN -- timed out
SELECT info.ringDetState FROM
idle => RETURN[FALSE];--??--
maybe => { info.ringDetState _ ring1; event _ enabled; RETURN[TRUE]; };
ring1, between => info.ringDetState _ idle;
ring => info.ringDetState _ between; --??--
ENDCASE;
info.ringDetWaitState _ info.ringDetState;
TRUSTED { SELECT info.ringDetState FROM
idle => { event _ disabled; RETURN[FALSE]; };
maybe => Process.SetTimeout[@info.ringDetCondition, debounceIntTicks];
ring1 => Process.SetTimeout[@info.ringDetCondition, ringIntTicks+breakIntTicks];
ring => Process.SetTimeout[@info.ringDetCondition, ringIntTicks];
between => Process.SetTimeout[@info.ringDetCondition, breakIntTicks];
ENDCASE;
};
WAIT info.ringDetCondition;
RETURN[ TRUE ]; };
DO
stillRunning:BOOL_ RingDetProcEntry[info];
IF event#reset THEN
smartsInfo.ParseEvent[smartsInfo, [info.ringChangeTime, ringDetect, event ] ];
IF ~stillRunning THEN RETURN; ENDLOOP; };

InterpretHookState: PUBLIC ENTRY PROC
[ info: LarkInfo, rawEvent: Lark.StatusEvent ]
RETURNS [ processedEvent: Lark.StatusEvent ] = {
ENABLE UNWIND=>NULL;
event: Lark.Event = rawEvent.event;
ev: EvType;
newState: HookState;
oldType: TerminalType_info.terminalType;
processedEvent.device _ nothing;
IF rawEvent.device = tones THEN {
ThSmartsPrivate.TonesDone[info, rawEvent, NIL];
RETURN;
};
ev _ SELECT rawEvent.device FROM
hookSwitch => SELECT event FROM
Lark.enabled => IF info.monitor THEN spMon ELSE tsOn, Lark.disabled => tsOff,
ThSmartsPrivate.click => spClick, ENDCASE=> spNone,
speakerSwitch => SELECT event FROM
Lark.enabled => spOn, Lark.disabled => spOff,
ThSmartsPrivate.click => spClick, ENDCASE => spNone,
ENDCASE => spNone;
processedEvent _ rawEvent;
IF ev = spNone THEN {
processedEvent.event _ SELECT rawEvent.device FROM
keyboard => SELECT event FROM
'[ => enabled,
'] => disabled,
'\n => endNum,
ENDCASE => event,
touchPad => SELECT event FROM
bThorp => endNum,
bStar => '*,
IN Lark.DTMFEvent => event - (FIRST[Lark.DTMFEvent]-'0),
ENDCASE=>event,
ENDCASE => event;
RETURN;
};

newState _ newStates[info.hookState][ev];
processedEvent.device _ IF newState=onhook OR info.hookState=onhook
THEN hookSwitch ELSE nothing;
IF event=ThSmartsPrivate.click THEN processedEvent.event_disabled;
info.hookState _ newState;
info.terminalType _ SELECT newState FROM
onhook => std,
telset, both, bOth => IF info.radio THEN radio ELSE std,
spkr, sPkr, spKr => IF info.radio THEN radio ELSE spkr,
monitor => monitor,
ENDCASE=> IF Log.ProblemBool[, $Lark, , info] THEN std ELSE std;
IF oldType#info.terminalType THEN
ThSmartsPrivate.EnterLarkSt[info, info.larkState, NIL];
};

unRevCommands: Lark.CommandEvents _ NEW[Lark.CommandEventSequence[2]];

CheckHookState: PUBLIC ENTRY PROC
[info: LarkInfo ] RETURNS [ onHook: BOOL_TRUE ] = {
ENABLE RPC.CallFailed => IF pd.callTimeoutOK THEN RESUME ELSE GOTO Failed;
reverted, wasReverted: BOOL_FALSE;
which: CARDINAL;
DO
which_0;
reverted _ FALSE;
DO
events: Lark.StatusEvents;
[which, events] _ info.interface.WhatIsStatus[info.shh, which];
FOR i: NAT IN [0..events.length) DO
SELECT events[i].event FROM
enabled => SELECT events[i].device FROM
hookSwitch => onHook_FALSE;
revertHookswitch => IF ~wasReverted THEN reverted _ wasReverted _ TRUE;
ENDCASE;
ENDCASE;
ENDLOOP;
IF which=0 THEN EXIT;
ENDLOOP;
IF reverted THEN {
info.interface.Commands[shh: info.shh, events: unRevCommands];
LOOP;
};
EXIT;
ENDLOOP;
EXITS
Failed => onHook_FALSE;
};

EvType: TYPE = { tsOn, tsOff, spOn, spOff, spClick, spMon, spNone };

newStates: ARRAY HookState OF ARRAY EvType OF HookState _ [
[ telset, onhook, sPkr, onhook, onhook, monitor, onhook ], -- onhook
[ telset, onhook, bOth, telset, telset, monitor, onhook ],   -- telset
[ telset, spkr, spKr, onhook, onhook, monitor, onhook ],  -- spkr
[ bOth, sPkr, sPkr, onhook, spkr, bOth, onhook ],     -- sPkr
[ bOth, sPkr, sPkr, onhook, onhook, bOth, onhook ],  -- spKr (sPkr, but click turns off.)
[ both, spkr, both, telset, telset, both, onhook ],       -- both
[ bOth, sPkr, bOth, telset, both, bOth, onhook ],       -- bOth
[ monitor, onhook, bOth, sPkr, monitor, monitor, onhook ] ]; -- monitor


ViewCmd: Commander.CommandProc = TRUSTED {
Nice.View[pd, "Lark In PD"];
};

unRevCommands[0] _ [aRelay, enabled];
unRevCommands[1] _ [revertHookswitch, disabled];

Commander.Register["VuLarkIn", ViewCmd, "Program Management variables for Lark Input"];
}.

âLarkInImpl.mesa 
Last modified by D. Swinehart, November 26, 1984 10:49:21 am PST
Actual hardware interface to Lark; includes process to keep tones going and eventually to deal with failure.
*****************  External  Procedures  ********************
Handles smarts-independent filtering, events that need timing.
Interpret event, possibly filter some out.
React to upstrokes, not downstrokes.  0-key Rollover is a side-effect.  Try it.
newly entered state
Filters only events whose device codes are hookswitch and speakerSwitch
Implements another state machine via SELECT
Translate characters from various devices into common set
Determine if either of telset or speakerphone is activated.
Assert aRelay and unrevert hookswitch
�Ê˜Jš
œ™Jš
œ@™@Jš
œl™lJ˜š
Ïk	˜	Jš�œ
˜Jšœ
�œ˜*Jšœ�œ¤
�œ˜µ
J˜Jšœ�œ�œ˜(J˜Jš�œ
�œ˜Jšœ�œ�œ˜Jšœ�œ,˜9Jšœ�œ˜$šœ�œ˜Jš
œw˜w—Jš	œ�œ�
œ
�œ�œ˜>Jšœ�œ˜J˜
J˜—šœ�
œ
�œ�œ˜9š
�˜Jšœ�œ�œ ˜F—Jš�œ˜&—Jš�œ
�œ
˜J˜Jš�
œ�œ�œ�œ�œ�œ�
œ˜JJšœ�œ˜,Jšœ
�œ˜*J˜2Jšœ�œ˜-Jšœ�œ˜.Jšœ�œ˜)Jšœ�œ ˜2Jš�œ�œ
�œ
˜J˜J˜!Jš
œ#˜#J˜!Jš
œ%˜%J˜J˜š�œ�œ�œ˜Jšœ�œ
�œ
Ïc2˜LJ˜—Jš	œ�œ
�œ�œ
�œ˜J˜Jš
œ=™=J˜J˜šÏnœ�œ+�œ˜AJš	œ�œ
�œ
�œ
�œ˜š
œ˜šœ�œ
˜
Jš
�œ�œ
�œ
�œ�œ
˜AJš�œ
�œ�œ˜ —Jšœ�œ
�œ�œ˜,—Jš�œ�œ˜3Jš�œ�œ
�œ�œ˜BJš
œ:˜:Jš
œ˜—J˜Jšœ	�œ
�œž1˜FšŸœ�œ
�œ�œA˜jJš�œ�	œ˜J™>Jš
œ˜Jš
œK˜KJ˜#Jš
œ˜J˜Jš�œ�œ
�œ�œ
�œ
�œ
�œ˜IJ˜ š�œ�œ�˜3J˜+Jš�œ�œ˜4Jš
�œ	�œ�œ�œ
�œ
˜KJ™*Jšœ�œ˜š�œ�˜šœ�
˜J˜%J˜B—šœ	�œ�˜!šœž˜Jš
œ
˜
J˜%J˜?J˜—Jš�œž˜ —Jš�œ
˜—š�œ�˜J˜?Jšœ1�
œ"˜Tš
œ
˜
J™OJš�œ�œ+˜Hš�œ˜Jšœ,�œž ˜RJ˜—Jš�œ�œ
�œ
˜ J˜—Jš�œ
˜—Jš�œ�œ
�œ
˜#Jš
œ>˜>Jš�œ˜——J˜šŸ	œ�œ
˜Jšœ�œ �œ�œ
˜\Jš�œ
�œ˜Jš�œ
˜Jš
œ˜—J˜šŸœ�œ*˜FJš�œ'žœ˜>Jšœ
�œ�œ˜8J˜š�œ�˜J˜'Jšœ�œ
˜Jš�œ�œ˜—Jš�œ�œ�œ
�œ
˜:J˜0J˜—Jšœ�œ˜J˜šŸœ�œ
�œZ˜yJš�œEžœ˜\Jš�œ
�œ�œ
˜Jšœ
�œ�œ"˜>J˜!J˜"š�œ�œ
˜Jšœ�œ�œ�œ�œ�œ
˜NJš	œ�œ�œ�œ�œ
˜IJš�œ�œ
˜—š�œ�˜šœ�œž˜%J˜J˜J˜.Jšœ�œ=˜P—šœž˜ š�œ�œ�œ˜?J˜J˜>——šœžœ
˜!J˜—šœ
ž˜Jšœ�œ�œ	�œ	˜I—šœ
ž˜ Jšœ�œ�œ�œ	˜G—Jš�œ
˜—Jš�œ)�œ
�œ˜PJ˜—Jšœ�œž˜'Jšœ�œ	ž0˜NJšœ�œ	ž0˜OJ˜HJ˜@J˜BJ˜J˜šŸœ�œ;�œ˜YJ˜%J˜šŸœ�œ
�œ�œ�œž
œ˜XJš�œ
�œ�œ
˜Jšœ�œ�œ�œ˜[J˜š�œ�œ �œ
ž˜Eš�œ�˜Jšœ�œ
�œž˜Jšœ7�œ
�œ˜GJš
œ+˜+Jšœ%ž˜+Jš�œ
˜——Jš
œ™Jš
œ*˜*š�œ�œ�˜'Jšœ�œ
�œ˜-Jš
œF˜FJš
œP˜PJš
œA˜AJš
œE˜EJš�œ
˜J˜—Jš�œ˜Jš�œ�œ˜—š
�˜Jšœ
�œ˜*š�œ
�˜Jš
œN˜N—Jš�œ�œ
�œ�œ˜)—J˜—šŸœ�œ
�œ
�˜%š
œ.˜.Jš�œ)˜0—Jšœ+Ïb
œ 
™GJšœ% ™+Jš�œ
�œ�œ
˜J˜#J˜J˜J˜(J˜ š�œ�œ˜!Jšœ*�œ˜/Jš�œ
˜J˜—šœ�œ�˜ šœ�œ�˜Jšœ�œ�œ�œ˜MJšœ"�œ
˜3—šœ�œ�˜"Jš
œ-˜-Jšœ"�œ˜4—Jš�œ˜—J˜š�œ
�œ˜J™9šœ�œ�˜2šœ�œ�˜J˜J˜J˜Jš�œ
˜—šœ�œ�˜J˜J˜Jš�œ�œ˜8Jš�œ˜—Jš�œ
˜—Jš�œ
˜š
œ˜J˜——Jš
œ)˜)šœ�œ�œ˜CJš�œ�œ	˜—Jš�œ�œ˜BJ˜šœ�œ
�˜(J˜Jšœ�œ�œ�œ˜8Jšœ�œ�œ�œ˜7Jš
œ˜Jš�œ�œ"�œ�œ˜@—š�œ�˜!Jšœ2�œ˜7—Jš
œ˜—J˜Jšœ$�œ˜FJ˜šŸœ�œ
�œ
�˜!Jšœ�œ�œ
�œ˜3J™;Jš�œ
�œ�œ�œ
�œ
�œ
�œ˜JJšœ�œ
�œ
˜"Jšœ�œ
˜š
�˜J˜Jšœ�œ
˜š
�˜J˜J˜?š�œ�œ
�œ�˜#š�œ�˜šœ�œ�˜'Jšœ�œ
˜Jšœ�œ�œ�œ
˜GJš�œ
˜—Jš�œ
˜—Jš�œ
˜—Jš�œ	�œ
�œ
˜Jš�œ
˜—š�œ
�œ˜J™%Jš
œ>˜>Jš�œ
˜J˜—Jš�œ
˜Jš�œ
˜—š
�˜Jšœ�œ
˜—J˜J˜—Jšœ�œ8˜DJ˜š	œ�œ�œ
�œ�œ˜;Jšœ;ž	˜DJšœ=ž	˜FJšœ:ž˜AJšœ6ž˜=Jš
œY˜YJšœ:ž˜AJšœ8ž˜?Jšœ=ž
˜GJ˜—J˜šœ!�œ˜*J˜Jš
œ˜J˜—J˜%J˜0J˜Jš
œW˜WJ˜J˜—…—*69'