IR(2)IR(2)NAMEir - infrared remote control module
SYNOPSIS
include "ir.m";
ir := load Ir Ir->PATH; # for real remotes
simir := load Ir Ir->SIMPATH; # for keyboard simulator
init: fn(irc: chan of int, pidc: chan of int): int;
translate: fn(key: int): int;
DESCRIPTION
Programs running with the Prefab toolkit (see prefab-intro(2)) are con‐
trolled by an infrared remote control device. If such a device is not
present, the system may simulate it from the keyboard by loading the
module in file Ir->SIMPATH. Although originally designed for use with
Prefab, these modules are general enough to be used directly by non-
Prefab applications.
The Ir module defines codes for representing the remote control keys.
Whether the remote is real or simulated, the init function does the
appropriate actions to initialize the device, and then spawns a process
to return the codes on the irc channel. The process ID of that process
is sent on the channel pidc when the process starts; init's caller must
receive it. It can be used to kill the controlling process when the
application finishes.
The codes are:
Ir->ChanUP, Ir->ChanDN
The Channel-Up and Channel-Down buttons. The keyboard equiva‐
lents are r and c.
Ir->Enter
The Enter button. The keyboard equivalent is the SPACE bar.
Ir->EOF
An end of file from the remote device. After sending one, no
more codes will be sent on irc.
Ir->Error
An unknown or invalid input from the remote device.
Ir->FF, Ir->Rew
The Fast-Forward and Rewind buttons. The keyboard equivalents
are k and j.
Ir->Mute
The Mute button. There is no keyboard equivalent.
Ir->Power
The Power button. The keyboard equivalent is the Delete key.
Ir->Rcl
The Recall button. The keyboard equivalent is x.
Ir->Record
The Record button. There is no keyboard equivalent.
Ir->Select
The Select button. The keyboard equivalent is the Return or
Enter key.
Ir->Up, Ir->Dn
The Up and Down buttons. The keyboard equivalents are i and m.
Ir->VolUP, Ir->VolDN
The Volume-Up and Volume-Down buttons. The keyboard equivalents
are t and v.
Ir->Zero, Ir->One, Ir->Two, etc.
The digit buttons, 0 through 9. The keyboard equivalents are
the corresponding numeral keys.
The translate function converts the device's raw codes into the con‐
stants defined by the module. For example, with the simulated remote
control, translate('3') returns Ir->Three. Translate is only necessary
for programs that wish to manage their own simulation of the remote.
Programs that drive the remote control directly, must load the appro‐
priate Ir implementation module and initialise it. The following exam‐
ple uses the absence of a simulator module to infer that a real remote
control is available.
implement Irtest;
include "sys.m";
include "draw.m";
include "ir.m";
Irtest: module
{
init: fn(ctxt: ref Draw->Context, argv: list of string);
};
init(nil: ref Draw->Context, nil: list of string)
{
sys := load Sys Sys->PATH;
# First try the keyboard Ir simulator.
# If that is not present, use Ir directly.
ir := load Ir Ir->SIMPATH;
if(ir == nil)
ir = load Ir Ir->PATH;
if(ir == nil){
sys->print("Ir module not loaded: %r\n");
return;
}
irc := chan of int;
pidc := chan of int;
if(ir->init(irc, pidc) < 0){
sys->print("Can't initialize Ir device: %r\n");
return;
}
pid := <-pidc;
while((irraw := <-irc) != Ir->EOF) {
irval := ir->translate(irraw);
if(irval == Ir->Power)
break;
sys->print("command %d -> %d\n", irraw, irval);
}
kill(pid);
}
Mux(1) provides one model for the use of an infrared remote control to
control a group of applications. Init is invoked once by mux, and the
codes then multiplexed between its applications as follows. Mux cre‐
ates a graphics context for each application (see draw-context(2)).
This context includes channels to the mux program and to the Ir device:
Draw->Context.ctomux and Draw->Context.cinput. Applications do not see
the Ir->Rcl command. Instead, mux program intercepts it and reacti‐
vates its own menu. The following example establishes communication
with mux and then reads Ir commands until it see Ir->Enter.
implement Command;
include "sys.m";
include "draw.m";
include "ir.m";
Command: module
{
init: fn(ref Draw->Context; list of string);
};
init(ctxt: ref Draw->Context; argv: list of string)
{
sys := load Sys Sys->PATH;
# Tell mux to start sending input.
ctxt.ctomux <-= Draw->AMstartinput;
for(;;) {
key := <-ctxt.cinput;
sys->print("command %d\n", key);
if(key == Ir->Enter)
break;
}
# Tell mux this thread is going away.
ctxt.ctomux <-= Draw->AMexit;
}
SOURCE
/appl/lib/ir.b
/appl/lib/irmpath.b
/appl/lib/irsim.b
SEE ALSOlimbo(1), mux(1), intro(2), draw-intro(2), prefab-intro(2)IR(2)