Modem-Vgetty
view release on metacpan or search on metacpan
$self->del_handler('RECEIVED_DTMF', 'readnum');
$self->stop;
$self->expect('READY');
$_readnum_number;
}
1;
__END__
=head1 NAME
Modem::Vgetty - interface to vgetty(8)
=head1 SYNOPSIS
use Modem::Vgetty;
$v = new Modem::Vgetty;
$string = $v->receive;
$v->send($string);
$string = $v->expect($str1, $str2, ...);
$v->waitfor($string);
$rv = $v->chat($expect1, $send1, $expect2, $send2, ...);
$ttyname = $v->getty;
$rv = $v->device($dev_type);
$rv = $v->autostop($bool);
$rv = $v->modem_type; # !!! see the docs below.
$rv = $v->beep($freq, $len);
$rv = $v->dial($number);
$rv = $v->play($filename);
$rv = $v->record($filename);
$rv = $v->wait($seconds);
$rv = $v->play_and_wait($filename);
$v->stop;
$v->add_handler($event, $handler_name, $handler);
$v->del_handler($event, $handler_name);
$v->enable_events;
$v->disable_events;
$number = $v->readnum($message, $tmout, $repeat);
$v->shutdown;
=head1 DESCRIPTION
C<Modem::Vgetty> is an encapsulation object for writing applications
for voice modems using the B<vgetty(8)> or B<vm(8)> package. The answering
machines and sofisticated voice applications can be written using this
module.
=head1 OVERVIEW
I<Voice modem> is a special kind of modem, which (besides the normal
data and/or fax mode) can communicate also in voice mode. It means
it can record sounds it hears from the phone line to the file,
Play-back recorded files, it can beep to the line, and it can detect
various standard sounds coming from the line (busy tone, silence,
dual tone modulation frequency (DTMF) keypad tones, etc).
An example of the voice modem can be the ZyXEL U1496, US Robotics
Sportster (not Courier), etc.
To use this software with the voice modem you need to have the
B<vgetty(8)> package installed. B<Vgetty> is distributed as a part of
B<mgetty> package. In fact, B<vgetty> is a B<mgetty(8)> with the voice
extensions. Vgetty has some support for scripting - when it receives
an incoming call, it runs a voice shell (it is program specified in
the B<voice.conf> file) as its child process, establishes the read
and write pipes to it, and tells it the number of the appropriate
descriptors in the environment variables. Voice shell can now
communicate with B<vgetty>. It can tell B<vgetty> "Play this file",
or "Record anything you hear to that file", or "Notify me when
user hangs up", etc. Sophisticated voice systems and answering
machines can be build on top of B<vgetty>.
B<mgetty> (including the B<vgetty>) is available at
the following URL:
ftp://alpha.greenie.net/pub/mgetty/
Originally there was a (Bourne) shell interface to B<vgetty> only.
The B<Modem::Vgetty> module allows user to write the voice shell in Perl.
The typical use is to write a script and point the B<vgetty> to it
(in B<voice.conf> file). The script will be run when somebody calls in.
Another use is running voice shell from the B<vm(8)> program, which
can for example dial somewhere and say something.
=head1 QUICK START
#!/usr/bin/perl
use Modem::Vgetty;
my $v = new Modem::Vgetty;
$v->add_handler('BUSY_TONE', 'endh', sub { $v->stop; exit(0); });
local $SIG{ALRM} = sub { $v->stop; };
$v->enable_events;
$v->record('/tmp/hello.rmd');
alarm(20);
$v->waitfor('READY');
$v->shutdown;
The above example installs the simple `exit now'-style handler for the
B<BUSY_TONE> event (which is sent by B<vgetty> when user hangs up)
and then records the B<hello.rmd> file. Put this text into a file
and then point B<vgetty> to it in the B<voice.conf>. After you dial into
your voice modem, you can record a 20-seconds of some message.
Verify that B</tmp/hello.rmd> exists. Now delete the line contaning
the word "record" and two subsequent lines and insert to the file
the following line instead of them:
$v->play_and_wait('/tmp/hello.rmd');
Now call the voice modem and listen to the sounds you have just recorded.
=head1 METHODS
=head2 Begin and end of communication
=item device($name)
Sets the port of the voice modem input and output is done to.
Possible values are qw(NO_DEVICE DIALUP_LINE EXTERNAL_MICROPHONE
INTERNAL_SPEAKER LOCAL_HANDSET).
=item autostop($bool)
With autostop on, the voicelib will automatically abort a
play in progress and return READY. This is useful for faster
reaction times for voice menus. Possible arguments are qw(ON OFF).
B<Note:> The interface should probably be changed to accept the
Perl boolean arguments (undef, something else). Returns defined
value on success, undef on failure.
=item modem_type
B<vgetty> currently has no way of telling voice shell
the type of the current modem. This method is a proposed interface
for determining this type. Currently returns B<undef>. The appropriate
low-level interface has to be implemented in B<vgetty> first.
=back
=head2 Voice commands
=over 4
=item beep($freq, $len)
Sends a beep through the chosen device using given frequency (HZ) and length
(in miliseconds).
Returns a defined value on success or undef on failure.
The state of the vgetty changes to "BEEPING" and B<vgetty>
returns "READY" after a beep is finshed. Example:
$v->beep(50,10);
# Possibly do something else
$v->waitfor('READY');
=item dial($number)
Modem tries to dial a given number. The B<vgetty> changes its state
to "DIALING" and returns "READY" after the dialing is finished.
=item play($filename)
The B<vgetty> tries to play the given file as a raw modem data.
See the "Voice data" section for details on creating the raw modem data
file. It changes the state to "PLAYING" and returns "READY" after
playing the whole file.
=item record($filename)
The B<vgetty> records the voice it can hear on the line to the given file.
It uses the raw modem data format (which can be re-played using the
B<play> subroutine). B<vgetty> changes its state to "RECORDING" and
you need to manually stop the recording using the B<stop> method
after some time (or, you can set B<autostop> and wait for any event
- silence, busy tone, etc).
=item wait($seconds)
The modem waits for a given number of seconds. Changes its state to
"WAITING" and returns "READY" after the wait is finished. Example:
$v->wait(5);
$v->waitfor('READY');
=item stop
The B<vgetty> stops anything it is currently doing and returns to the
command state. You must use B<stop> when you want to call another
B<beep>, B<dial>, B<play>, B<record> or B<wait> before the previous
one is finished. The B<vgetty> returns "READY" after the B<stop>
is called. So it is possible to interrupt a main routine waiting
for "READY" from the event handler:
my $dtmf;
$v->add_handler('RECEIVED_DTMF', 'readnum',
sub { my $self=shift; $self->stop; $dtmf = $_[2]; });
$v->enable_events;
$v->wait(10);
$v->waitfor('READY');
In the previous example the B<waitfor> method can be finished either by
the 10-second timeout expired, or by the 'READY' generated by the
B<stop> in the event handler. See also the B<Events> section.
=item play_and_wait($file)
It is an abbreviation for the following:
$v->play($file);
$v->waitfor('READY');
It is repeated so much time in the voice applications so I have decided
to make a special routine for it. I may add the similar routines
for B<dial>, B<record>, B<beep> and even B<wait> in the future releases.
=back
=head2 Event handler methods
=over 4
=item add_handler($event, $handler_name, $handler)
Installs a call-back routine $handler for the event type $event.
The call-back routine is called with three arguments. The first
one is the Modem::Vgetty object itself, the second one is the
event name and the third one is optional event argument.
The B<$handler_name> argument can be anything. It is used when you
want to delete this handler for identificating it.
=item del_handler($event, $handler_name)
This method deletes the handler $handler_name for the $event event.
The result of unregistering the handler from the
event handler of the same event is unspecified. It may or may not be
No events are sent by B<vgetty> until this method is called.
=item disable_events
Tells the B<vgetty> that the voice shell doesn't want to receive
any events anymore.
=back
=head2 The B<readnum> method
=over 4
=item readnum($message, $tmout, $repeat)
The applications often need to read the multi-digit
number via the DTMF tones. This routine plays the B<$message> to the
voice object and then waits for the
sequence of the DTMF keys finished by the `#' key. If no key is pressed
for B<$tmout> of seconds, it re-plays the message again. It returns
failure if no key is pressed after the message is played B<$repeat>-th
time. It returns a string (a sequence of DTMF tones 0-9,A-D and `*')
without the final `#'. When some DTMF tones are received and no terminating
`#' or other tone is received for B<$tmout> seconds, the routine returns
the string it currently has without waiting for the final '#'.
DTMF tones are accepted even at the time the B<$message> is played.
When the DTMF tone is received, the playing of the B<$message> is
(with some latency, of course) stopped.
B<NOTE:> The interface of this routine can be changed in future releases,
because I am not (yet) decided whether the current interface is the best one.
See also the B<EXAMPLES> section where the source code of this routine
(and its co-routine) is discussed.
=back
=head1 EVENTS
=head2 Introduction
Events are asynchronous messages sent by B<vgetty> to the voice shell.
The B<Modem::Vgetty> module dispatches events itself in the B<receive>
method. User can register any number of handlers for each event.
When an event arrives, all handlers for that event are called (in no
specified order).
=head2 Event types
At this time, the B<Modem::Vgetty> module recognizes the following
event types (description is mostly re-typed from the B<vgetty>
documentation):
=over 4
=item BONG_TONE
The modem detected a bong tone on the line.
=item BUSY_TONE
The modem detected busy tone on the line (when dialing to the busy
number or when caller finished the call).
=item CALL_WAITING
Defined in IS-101 (I think it is when the line receives another call-in
when some call is already in progress. -Yenya).
=item DIAL_TONE
The modem detected dial tone on the line.
=item DATA_CALLING_TONE
The modem detected data calling tone on the line.
=item DATA_OR_FAX_DETECTED
The modem detected data or fax calling tones on the line.
=item FAX_CALLING_TONE
The modem detected fax calling tone on the line.
=item HANDSET_ON_HOOK
Locally connected handset went on hook.
=item HANDSET_OFF_HOOK
Locally connected handset went off hook.
=item LOOP_BREAK
Defined in IS-101.
=item LOOP_POLARITY_CHANGE
Defined in IS-101.
=item NO_ANSWER
After dialing the modem didn't detect answer for the time
give in dial_timeout in voice.conf.
=item NO_DIAL_TONE
The modem didn't detect dial tone (make sure your modem is
connected properly to your telephone company's line, or check
the ATX command if dial tone in your system differs from
the standard).
=item NO_VOICE_ENERGY
It means that the modem detected voice energy at the
beginning of the session, but after that there was a
period of some time of silence (the actual time can be set using
the B<rec_silence_len> and B<rec_silence_treshold> parameters
in B<voice.conf>).
=item RING_DETECTED
=item TDD_DETECTED
Defined in IS-101.
=item VOICE_DETECTED
The modem detected a voice signal on the line. IS-101 does
not define, how the modem makes this decision, so be careful.
=item UNKNOWN_EVENT
None of the above :)
=back
=head1 VOICE DATA
Voice shell can send the voice data to the modem using the B<play>
method and record them using the B<record> method. The ".rmd" extension
(Raw Modem Data) is usually used for these files. The ".rmd" is not
a single format - every modem has its own format (sampling frequency,
data bit depth, etc). There is a B<pvftools> package for converting
the sound files (it is a set of filters similar to the B<netpbm> for image
files). The B<pvftormd(1)> filter can be used to create the RMD files
for all known types of modems.
=head1 EXAMPLES
=head2 Answering machine
A simple answering machine can look like this:
#!/usr/bin/perl
use Modem::Vgetty;
my $voicemaster = 'root@localhost';
my $tmout = 30;
my $finish = 0;
my $v = new Modem::Vgetty;
$v->add_handler('BUSY_TONE', 'finish',
sub { $v->stop; $finish=1; });
$v->add_handler('SILENCE_DETECTED', 'finish',
sub { $v->stop; $finish=1; });
local $SIG{ALRM} = sub { $v->stop; };
$v->enable_events;
$v->play_and_wait('/path/welcome.rmd');
$v->beep(100,10);
$v->waitfor('READY');
if ($finish == 0) {
my $num = 0;
$num++ while(-r "/path/$num.rmd");
$v->record("/path/$num.rmd");
alarm $tmout;
$v->waitfor('READY');
}
system "echo 'Play with rmdtopvf /path/$num.rmd|pvftoau >/dev/audio'" .
" | mail -s 'New voice message' $voicemaster";
exit 0;
See the B<examples/answering_machine.pl> in the source distribution,
which contains a more configurable version of the above text.
It first sets the event handlers for the case of busy tone (the caller
hangs up) or silence (the caller doesn't speak at all). The handler
stops B<vgetty> from anything it is currently doing and sets the $finish
variable to 1. Then the reception of the events is enabled and
the welcome message is played. Then the answering machine beeps
and starts to record the message. Note that we need to check the
$finish variable before we start recording to determine if user
hanged up the phone. Now we find the first filename <number>.rmd
such that this file does not exist and we start to record the message
to this file. We record until user hangs up the phone or until
the timeout occurs.
=head2 Readnum routine
An interesting application of the low-level routines is the
B<Voice::Modem::readnum> method. The calling sequence of this method
has been discussed above. The source code for this routine and its
co-routine will be discussed here, so that you can write your own
variants of B<readnum> (which in fact does not have too general
interface). See also the source code of B<Vgetty.pm> for the B<readnum>
source.
The B<readnum> routine needs to have its own event handler for the
B<RECEIVED_DTMF> event and the way the handler can communicate with
this routine. In our solution we use "static" variables:
my $_readnum_number = '';
my $_readnum_timeout = 10;
my $_readnum_in_timeout = 1;
The event handler will add the new character to the end of the
B<$_readnum_number> variable. The B<$_readnum_timeout> is the number
of seconds both B<readnum> and the event handler should wait for the
next keypress, and the B<$_readnum_in_timeout> is a flag used by the
event handler for notifying the main B<readnum> routine that it forced
the B<vgetty> to emit the `READY' message because of the final `#'
has been received.
sub _readnum_event {
my $self = shift;
my $input = shift; # Unused. Should be 'RECEIVED_DTMF'.
my $dtmf = shift;
if ($dtmf eq '#') { # Stop the reading now.
$_readnum_in_timeout = 0;
$self->stop;
$self->{LOG}->print("_readnum_event(): Got #; stopping\n");
return;
}
$_readnum_number .= $dtmf;
$self->stop;
$self->expect('READY');
# Restart the wait again.
$_readnum_in_timeout = 1;
$self->wait($_readnum_timeout);
}
The event handler is installed for the `RECEIVED_DTMF' event only, so it
doesn't need to check for the B<$input> value. The actual DTMF key is in
the third parameter, B<$dtmf>. Note that the handler will be called
when B<vgetty> is PLAYING or WAITING and the B<readnum> routine will
( run in 1.840 second using v1.01-cache-2.11-cpan-39bf76dae61 )