Device-Modem-1.57/0000755000175000017500000000000012271163063013251 5ustar cosimocosimoDevice-Modem-1.57/MANIFEST0000644000175000017500000000055011641055116014401 0ustar cosimocosimoChanges examples/active.pl examples/caller-id.pl examples/dial.pl examples/shell.pl examples/xmodem.pl lib/Device/Modem.pm lib/Device/Modem/FAQ.pod lib/Device/Modem/Log/File.pm lib/Device/Modem/Log/Syslog.pm lib/Device/Modem/Protocol/Xmodem.pm lib/Device/Modem/UsRobotics.pm Makefile.PL MANIFEST META.yml Module meta-data (added by MakeMaker) README test.pl Device-Modem-1.57/examples/0000755000175000017500000000000012271163063015067 5ustar cosimocosimoDevice-Modem-1.57/examples/active.pl0000644000175000017500000000266611470304031016701 0ustar cosimocosimo# $Id: active.pl,v 1.4 2005-04-30 21:45:47 cosimo Exp $ # # This script tries to test if modem is active (on and enabled) # If modem is not active, tries to reset it. # # As I know, this script works to the extent as it: # # 1) Fails if modem is turned off # 2) Succeeds if modem is turned on # # It's not a big thing, I know ... :-( # use Device::Modem; my %config; my $port; if( open CACHED_CONFIG, '< ../.config' ) { while( ) { my @t = split /[\s\t]+/; $config{ $t[0] } = $t[1]; } close CACHED_CONFIG; } if( $config{'tty'} ) { print "Your serial port is `$config{'tty'}' (cached)\n"; $port = $config{'tty'}; } else { $config{'tty'} = $Device::Modem::DEFAULT_PORT; print "What is your serial port? [$config{'tty'}] "; chomp( $port = ); $port ||= $config{'tty'}; if( open( CONFIG, '>../.config' ) ) { print CONFIG "tty\t$port\n"; close CONFIG; } } # ----------------------------------------------------- # BEGIN OF TESTS # ----------------------------------------------------- my $modem = new Device::Modem( port => $port ); if( $modem->connect( baudrate => $config{'baud'} || 19200 ) ) { print "ok 2\n"; } else { print "not ok 2\n"; die "cannot connect to $port serial port!: $!"; } print '- testing if modem is turned on and available', "\n"; my $lOk = 0; if( $lOk = $modem->is_active() ) { print "Ok, modem is active\n"; } else { print "NO! Modem is turned off, or not functioning...\n"; } Device-Modem-1.57/examples/xmodem.pl0000644000175000017500000000065711470304031016715 0ustar cosimocosimo#!/usr/bin/perl use Device::Modem; use Device::Modem::Protocol::Xmodem; my $port = $ARGV[0] || '/dev/pts/1'; my $mdm = Device::Modem->new( port => $port ); $mdm->connect( baudrate => 9600 ) or die "Can't connect to port $port"; print "Ok, connected. Press a key to begin transfer..."; ; my $recv = Xmodem::Receiver->new( modem => $mdm ); die "Receiver object undef!" if ! $recv; $recv->run() or die "Cannot receive!"; Device-Modem-1.57/examples/dial.pl0000644000175000017500000000237111470304031016330 0ustar cosimocosimo# $Id: dial.pl,v 1.3 2005-04-30 21:45:47 cosimo Exp $ # # This script tries to dial a number taken from STDIN # or as first argument. # # Example: # perl dial.pl 012,3456789 # # 03/06/2002 Cosimo # use Device::Modem; my %config; my $port; if( open CACHED_CONFIG, '< ../.config' ) { while( ) { my @t = split /[\s\t]+/; $config{ $t[0] } = $t[1]; } close CACHED_CONFIG; } if( $config{'tty'} ) { print "Your serial port is `$config{'tty'}' (cached)\n"; $port ||= $config{'tty'}; } else { $config{'tty'} = $Device::Modem::DEFAULT_PORT; print "What is your serial port? [$config{'tty'}] "; chomp( $port = ); $port ||= $config{'tty'}; if( open( CONFIG, '>../.config' ) ) { print CONFIG "tty\t$port\n"; close CONFIG; } } my $modem = new Device::Modem( port => $port ); if( $modem->connect( baudrate => $config{'baud'} || 19200 ) ) { print "ok connected.\n"; } else { die "cannot connect to $port serial port!: $!"; } my $number = $ARGV[0]; while( ! $number ) { print "\nInsert the number to dial: \n"; $number = ; chomp $number; $number =~ s/\D//g; } print '- trying to dial [', $number, ']', "\n"; if( $lOk = $modem->dial($number,30) ) { print "Ok, number dialed\n"; } else { print "No luck!\n"; } Device-Modem-1.57/examples/caller-id.pl0000644000175000017500000000260511470304031017253 0ustar cosimocosimo#!/usr/bin/perl # # Demo of "Caller id" feature: detect who is calling us! # Thanks to Marcelo Fernandez (mfernandez@lq.com.ar) # # $Id: caller-id.pl,v 1.1 2004-08-18 07:29:10 cosimo Exp $ # use Device::Modem; # Init modem my $port = '/dev/ttyS0'; my $baud = 9600; my $modem = new Device::Modem ( port => $port ); die "Can't connect to port $port!\n" unless $modem->connect( baudrate => $baud ); print "Connected to $port.\n\n"; # Init ATs #$modem->atsend('AT S7=45 S0=0 L1 V1 X4 &c1 E1 Q0'.Device::Modem::CR); # 'Stolen' from minicom :P # Set modem in autoanswer mode (to receive incoming calls) # Doesn't work (it says "NO CARRIER") if I uncomment it # $modem->atsend('ATA'.Device::Modem::CR); # Enable Caller ID info $modem->atsend('AT#CID=1'.Device::Modem::CR); # Poll state of modem my $received_call = 0; my $number = ''; print "Waiting for call...\n"; while( ! $received_call ) { # Listen for data coming from modem my $cid_info = $modem->answer(undef, 3); # 3 seconds timeout print "$cid_info\n" if ($cid_info); # If something received, take a look at it if( $cid_info =~ /NMBR\s*=\s*([\d\s]+)/ ) { # Ok, received! Number is in $1 var $number = $1; $received_call++; print "\nNumber $number IS CALLING!!\n"; } elsif( $cid_info ) { # Received something else, we must investigate } else { # No data received. No call arrived. } # Repeat until done } $modem->disconnect(); Device-Modem-1.57/examples/shell.pl0000644000175000017500000000200111470304031016514 0ustar cosimocosimo#!/usr/bin/perl # # Simple test program that executes a modem `shell' # to monitor AT command results. # # ****************************************** # If it does not work, try with baud = 9600 # # $Id: shell.pl,v 1.6 2005-04-30 21:45:47 cosimo Exp $ use strict; use Device::Modem; if( $> && $< ) { print "\n*** REMEMBER to run this program as root if you cannot connect on serial port!\n"; sleep 3; } print "Your serial port? [/dev/ttyS0]\n"; my $port = ; chomp $port; $port ||= '/dev/ttyS0'; print "Your baud rate? [19200]\n"; my $baud = ; chomp $baud; $baud ||= 19200; my $modem = new Device::Modem ( port => $port ); my $stop; die "Could not connect to $port!\n" unless $modem->connect( baudrate => $baud ); print "Connected to $port.\n\n"; while( not $stop ) { print "insert AT command (`stop' to quit)\n"; print "> "; my $AT = ; chomp $AT; if( $AT eq 'stop' ) { $stop = 1; } else { $modem->atsend( $AT . "\r\n" ); print $modem->answer(), "\n"; } } print "Done.\n"; Device-Modem-1.57/Changes0000644000175000017500000001722712271162567014565 0ustar cosimocosimoRevision history for Perl extension Device::Modem. 1.57 Sun Jan 26 11:36:11 CET 2014 - Added a "handshake" option to the connect() method. Allowed values are "xoff", "rts" or "none" (default). Thanks to Ezio Bonsi for suggesting the idea. 1.56 Thu Sep 29 13:43:31 CEST 2011 - [RT#71330] Unbroken the MANIFEST file. 1.55 was non functional. Thanks to Vita Cizek for reporting. 1.55 [BROKEN RELEASE. AVOID] Fri Sep 23 22:01:31 CEST 2011 - Performance improvements by Ed Wildgoose, long time user. Thanks Ed! Windows users, please test this release! 1.54 Sun May 29 20:53:23 AEST 2011 - Removed uninitialized warning on $obj->{'CONNECTED'}. Fixes RT #68504. 1.53 Thu Apr 01 13:49:00 CET 2010 - ***CHANGED*** default log file position from /var/log/modem.log to /tmp/modem.log. Too many failed tests and user reports made me reconsider my poor default choice. - Added voice dialing. Just dialing though. You can't perform real voice calls through Device::Modem (yet :) Thanks to Marek Jaros. - Added ';' (voice dialing) and 'p' (pause) as valid values for dial() number. 1.52 Sun Mar 28 15:50:00 CET 2010 - Added automatic port reconnection in the port() method. This should improve connection reliability and reduce risk of "Can't call method XXXXXX on undefined value YYYYYY" errors. 1.51 Sun Jul 5 09:46:08 CEST 2009 - Fixed documentation for answer() method, timeout was declared to be in seconds instead of milliseconds. Thanks to Mikko Puisto for reporting. 1.50 Tue Sep 30 22:59:00 CEST 2008 - Fixed use of wrong 'error' loglevel for SysLog plugin 1.49 Sat May 31 22:38:00 CEST 2008 - Changed default wait cycles and timeout to be more reliable with slow devices after several user reports. - Fixed man page for Xmodem.pm module. Incorporated fix from the debian package. 1.48 Sun Jun 24 09:30:16 CEST 2007 - atsend() method made more reliable with longer commands (ex. longer sms messages). Thanks to Ben Knight for his bug report and patch. 1.47 Thu Apr 20 22:16:17 CET 2006 - Sensible speedup in the command/response cycle. Thanks to Ed Wildgoose for his contribution. 1.46 1.45 Tue Nov 15 23:29:40 CET 2005 - Fixed dial() now it does not wait for timeout in presence of a valid remote response (NO CARRIER, BUSY, ...) - Fine tuned answer read cycle times - Added constant $Device::Modem::WAITCMD for wait time before issuing commands (atsend) - Added patch to make Xmodem work from Aaron Mitti . - Now dial() accepts also '#' sign in numbers (thanks to Pierre Hilson). 1.44 Sat Apr 30 23:29:03 CET 2005 - (again) now cygwin and darwin platforms should be detected correctly. (thanks to Rob Johnson for reporting) - added a preliminary version of Device::Modem::UsRobotics module, that allows to access voice/fax messages stored on your UsRobotics message modem. Read the (incomplete) docs for more details. 1.42 Sun Sep 19 21:12:10 CET 2004 - little fix for correct MacOSX os detection and SerialPort inclusion (thanks to Lidie Steve for reporting) 1.39 1.38 1.37 Wed Aug 18 09:21:50 CET 2004 - parse_answer() now in scalar context (string) returns *all* modem answer instead of removing the last string (OK/ERROR/...) - documented new example scripts: caller-id.pl and xmodem.pl 1.36 1.35 1.34 Sun Feb 22 18:12:54 CET 2004 - fixed CPAN bug #5131 (https://rt.cpan.org/Ticket/Display.html?id=5131) - closed CPAN bug #5134 (https://rt.cpan.org/Ticket/Display.html?id=5134) - dial() now should return correctly after a successful connect, without unnecessarily waiting for timeout - updated changes file missing in 1.35 1.33 1.32 1.31 Fri Jan 23 01:14:01 CET 2004 - Improved reliability in answer() method (sempre lui!), that was more unstable due to recent changes. - Documented _answer() internal function to get the raw modem reponse instead of response string stripped of all cr/lf chars. 1.29 1.30 Sat Nov 8 18:23:02 CET 2003 - improved answer() method speed. Now it runs sensibly faster, but needs explicit timeout parameter if you want to wait for answers (dialing a remote modem, for example) - implemented a basic xmodem file transfer. *DON'T KNOW IF IT WORKS* - documentation now stays only in docs/ folder, separate from main module - now there is a way to get the raw modem answers (internal _answer() method) 1.25 1.26 1.27 1.28 Sun May 18 17:19:23 CET 2003 - dial() now works as expected, returning the `CONNECT' or `BUSY' or whatever message without hanging for minutes; - answer() routine now is definitely more reliable than before: now everytime the buffer receives input from modem, it does not restart counting the timeout. Removed also the possibility of infinite loop if modem always receives garbage chars (like on a RAW PPP link); - Added full documentation for every method; - Added a FAQ document in new "docs/" folder; - new(): added possibility to pass a custom log object as `log' property; - fixed log levels for File and Syslog plugins. Implemented correct log level masking also for Syslog. 1.23 Wed Dec 4 00:34:52 CET 2002 - little documentation adjustments in main Modem.pm class; - removed use of `warnings.pm' - now File log class opens the log file once and writes on already opened file handle, until final close(). - Thanks to Joerg Neuberger for spotting out a problem with older perls (5.005_xx) and `use warnings' 1.19 1.20 Thu Sep 12 00:19:11 CEST 2002 1.22 Thu Sep 26 00:16:49 CEST 2002 - improved command/response cycle with proper handling of timeout and idle/data cycles. Now it is more reliable also with fairly big serial messages (removed this from TODO list). - removed warnings on undefined answer strings. 1.17 1.18 Tue Sep 3 21:57:11 CEST 2002 - removed some warnings and error in regexp pattern, slight changes in documentation 1.16 Mon Jun 17 21:58:22 CEST 2002 - added S_register() method to read/write S-registers; - store_number() to store an address-book number (cannot retrieve yet); - restore_factory_settings() now accepts a number of profile (default=0); - dial() now dials also address book numbers (only if supplied number is composed of 1 digit: the address book position, from 0 to 9). - status() method added, which looks up CTS, DSR, RLSD and RING signals; 1.15 Tue Jun 04 23:20:12 CEST 2002 - modified makefile/test procedure to pass automated cpan tests 1.14 Mon Jun 03 21:53:05 CEST 2002 - added is_active() method to test if modem ... (guess :-) - tested, now seems to work, dial() method - fixed a *bad* bug in modem answer parsing routine - better timing and less waits in AT commands - moved "PRE-ALPHA" to "ALPHA" :-) 1.10 Wed Apr 10 00:11:35 CEST 2002 - modified docs, license details - fixed wrong hangup() call 1.08 Wed Apr 3 23:31:58 CEST 2002 - fixed logging classes auto-load mechanism - added parse_answer() function, to easily retrieve informational responses - added TO-DO list to pod 1.07 Wed Apr 3 22:05:00 CEST 2002 - renamed `serial' parameter as `port', syncing with existent docs - removed some warnings on parameters passing 1.05 Sat Mar 30 16:19:40 CET 2002 - added and documented dial() and repeat(), still to be tested! 1.04 Mon Mar 25 07:37:20 CET 2002 - cleaned up docs and some of source code 0.01 Tue Feb 26 22:15:22 CET 2002 - original version; created by h2xs 1.20 with options -A -X -n Device::Modem -v 0.01 Device-Modem-1.57/lib/0000755000175000017500000000000012271163063014017 5ustar cosimocosimoDevice-Modem-1.57/lib/Device/0000755000175000017500000000000012271163063015216 5ustar cosimocosimoDevice-Modem-1.57/lib/Device/Modem.pm0000755000175000017500000012444312271162404016626 0ustar cosimocosimo# Device::Modem - a Perl class to interface generic modems (AT-compliant) # Copyright (C) 2002-2014 Cosimo Streppone, cosimo@cpan.org # # This program is free software; you can redistribute it and/or # modify it under the same terms as Perl itself. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # Perl licensing terms for details. package Device::Modem; $VERSION = '1.57'; BEGIN { if( index($^O, 'Win') >= 0 ) { # MSWin32 (and not darwin, cygwin, ...) require Win32::SerialPort; import Win32::SerialPort; # Import line status constants from Win32::SerialPort module *Device::Modem::MS_CTS_ON = *Win32::SerialPort::MS_CTS_ON; *Device::Modem::MS_DSR_ON = *Win32::SerialPort::MS_DSR_ON; *Device::Modem::MS_RING_ON = *Win32::SerialPort::MS_RING_ON; *Device::Modem::MS_RLSD_ON = *Win32::SerialPort::MS_RLSD_ON; } else { require Device::SerialPort; import Device::SerialPort; # Import line status constants from Device::SerialPort module *Device::Modem::MS_CTS_ON = *Device::SerialPort::MS_CTS_ON; *Device::Modem::MS_DSR_ON = *Device::SerialPort::MS_DSR_ON; *Device::Modem::MS_RING_ON = *Device::SerialPort::MS_RING_ON; *Device::Modem::MS_RLSD_ON = *Device::SerialPort::MS_RLSD_ON; } } use strict; use Carp (); # Constants definition use constant CTRL_Z => chr(26); use constant CR => "\r"; # Connection defaults $Device::Modem::DEFAULT_PORT = index($^O, 'Win') >= 0 ? 'COM1' : '/dev/modem'; $Device::Modem::DEFAULT_INIT_STRING = 'S7=45 S0=0 L1 V1 X4 &c1 E1 Q0'; $Device::Modem::BAUDRATE = 19200; $Device::Modem::DATABITS = 8; $Device::Modem::STOPBITS = 1; $Device::Modem::HANDSHAKE= 'none'; $Device::Modem::PARITY = 'none'; $Device::Modem::TIMEOUT = 500; # milliseconds $Device::Modem::READCHARS= 130; $Device::Modem::WAITCMD = 200; # milliseconds # Setup text and numerical response codes @Device::Modem::RESPONSE = ( 'OK', undef, 'RING', 'NO CARRIER', 'ERROR', undef, 'NO DIALTONE', 'BUSY' ); $Device::Modem::STD_RESPONSE = qr/^(OK|ERROR|COMMAND NOT SUPPORT)$/m; #%Device::Modem::RESPONSE = ( # 'OK' => 'Command executed without errors', # 'RING' => 'Detected phone ring', # 'NO CARRIER' => 'Link not established or disconnected', # 'ERROR' => 'Invalid command or command line too long', # 'NO DIALTONE' => 'No dial tone, dialing not possible or wrong mode', # 'BUSY' => 'Remote terminal busy' #); # object constructor (prepare only object) sub new { my($proto,%aOpt) = @_; # Get reference to object # Options of object my $class = ref($proto) || $proto; # Get reference to class $aOpt{'ostype'} = $^O; # Store OSTYPE in object $aOpt{'ostype'} = 'windoze' if index( $aOpt{'ostype'}, 'Win' ) >= 0; # Initialize flags array $aOpt{'flags'} = {}; # Start as not connected $aOpt{'CONNECTED'} = 0; $aOpt{'port'} ||= $Device::Modem::DEFAULT_PORT; # Instance log object $aOpt{'log'} ||= 'file'; # Force logging to file if this is windoze and user requested syslog mechanism $aOpt{'log'} = 'file' if( $aOpt{'ostype'} eq 'windoze' && $aOpt{'log'} =~ /syslog/i ); $aOpt{'loglevel'} ||= 'warning'; if( ! ref $aOpt{'log'} ) { my($method, @options) = split ',', delete $aOpt{'log'}; my $logclass = 'Device/Modem/Log/'.ucfirst(lc $method).'.pm'; my $package = 'Device::Modem::Log::'.ucfirst lc $method; eval { require $logclass; }; unless($@) { $aOpt{'_log'} = $package->new( $class, @options ); } else { print STDERR "Failed to require Log package: $@\n"; } } else { # User passed an already instanced log object $aOpt{'_log'} = $aOpt{'log'}; } if( ref $aOpt{'_log'} && $aOpt{'_log'}->can('loglevel') ) { $aOpt{'_log'}->loglevel($aOpt{'loglevel'}); } bless \%aOpt, $class; # Instance $class object } sub attention { my $self = shift; $self->log->write('info', 'sending attention sequence...'); # Send attention sequence $self->atsend('+++'); # Wait for response $self->answer(); } sub dial { my($self, $number, $timeout, $mode) = @_; my $ok = 0; # Default timeout in seconds $timeout ||= 30; # Default is data calls if (! defined $mode) { $mode = 'DATA'; } # Numbers with ';' mean voice calls elsif ($mode =~ m{VOICE}i || $number =~ m{;}) { $mode = 'VOICE'; } # Invalid input, or explicit 'DATA' call else { $mode = 'DATA'; } # Check if we have already dialed some number... if ($self->flag('CARRIER')) { $self->log->write( 'warning', 'line is already connected, ignoring dial()' ); return; } # Check if no number supplied if (! defined $number) { # # XXX Here we could enable ATDL command (dial last number) # $self->log->write( 'warning', 'cannot dial without a number!' ); return; } # Remove all non number chars plus some others allowed # Thanks to Pierre Hilson for the `#' (UMTS) # and to Marek Jaros for the `;' (voice calls) $number =~ s{[^0-9,\(\)\*\-#;\sp]}{}g; my $suffix = ''; if ($mode eq 'VOICE') { $self->log->write('info', 'trying to make a voice call'); $suffix = ';'; } # Dial number and wait for response if( length $number == 1 ) { $self->log->write('info', 'dialing address book number ['.$number.']' ); $self->atsend( 'ATDS' . $number . $suffix . CR ); } else { $self->log->write('info', 'dialing number ['.$number.']' ); $self->atsend( 'ATDT' . $number . $suffix . CR ); } # XXX Check response times here (timeout!) my $ans = $self->answer( qr/[A-Z]/, $timeout * 1000 ); if( (index($ans,'CONNECT') > -1) || (index($ans,'RING') > -1) ) { $ok = 1; } # Turn on/off `CARRIER' flag $self->flag('CARRIER', $ok); $self->log->write('info', 'dialing result = '.$ok); return wantarray ? ($ok, $ans) : $ok; } # Enable/disable local echo of commands (enabling echo can cause everything else to fail, I think) sub echo { my($self, $lEnable) = @_; $self->log->write( 'info', ( $lEnable ? 'enabling' : 'disabling' ) . ' echo' ); $self->atsend( ($lEnable ? 'ATE1' : 'ATE0') . CR ); $self->answer($Device::Modem::STD_RESPONSE); } # Terminate current call (XXX not tested) sub hangup { my $self = shift; $self->log->write('info', 'hanging up...'); $self->atsend( 'ATH0' . CR ); my $ok = $self->answer($Device::Modem::STD_RESPONSE); unless ($ok) { $self->attention(); $self->atsend( 'ATH0' . CR ); $self->answer($Device::Modem::STD_RESPONSE, 5000); } $self->_reset_flags(); } # Checks if modem is enabled (for now, it works ok for modem OFF/ON case) sub is_active { my $self = shift; my $lOk; $self->log->write('info', 'testing modem activity on port ' . ($self->options->{'port'} || '') ); # Modem is active if already connected to a line if( $self->flag('CARRIER') ) { $self->log->write('info', 'carrier is '.$self->flag('CARRIER').', modem is connected, it should be active'); $lOk = 1; } else { # XXX Old mode to test modem ... # Try sending an echo enable|disable command #$self->attention(); #$self->verbose(0); #$lOk = $self->verbose(1); # If DSR signal is on, modem is active my %sig = $self->status(); $lOk = $sig{DSR}; undef %sig; # If we have no success, try to reset if( ! $lOk ) { $self->log->write('warning', 'modem not responding... trying to reset'); $lOk = $self->reset(); } } $self->log->write('info', 'modem reset result = '.$lOk); return $lOk; } # Take modem off hook, prepare to dial sub offhook { my $self = shift; $self->log->write('info', 'taking off hook'); $self->atsend( 'ATH1' . CR ); $self->flag('OFFHOOK', 1); return 1; } # Get/Set S* registers value: S_register( number [, new_value] ) # returns undef on failure ( zero is a good value ) sub S_register { my $self = shift; my $register = shift; my $value = 0; return unless $register; my $ok; # If `new_value' supplied, we want to update value of this register if( @_ ) { my $new_value = shift; $new_value =~ s|\D||g; $self->log->write('info', 'storing value ['.$new_value.'] into register S'.$register); $self->atsend( sprintf( 'AT S%02d=%d' . CR, $register, $new_value ) ); $value = ( index( $self->answer(), 'OK' ) != -1 ) ? $new_value : undef; } else { $self->atsend( sprintf( 'AT S%d?' . CR, $register ) ); ($ok, $value) = $self->parse_answer(); if( index($ok, 'OK') != -1 ) { $self->log->write('info', 'value of S'.$register.' register seems to be ['.$value.']'); } else { $value = undef; $self->log->write('err', 'error reading value of S'.$register.' register'); } } # Return updated value of register $self->log->write('info', 'S'.$register.' = '.$value); return $value; } # Repeat the last commands (this comes gratis with `A/' at-command) sub repeat { my $self = shift; $self->log->write('info', 'repeating last command' ); $self->atsend( 'A/' . CR ); $self->answer(); } # Complete modem reset sub reset { my $self = shift; $self->log->write('warning', 'resetting modem on '.$self->{'port'} ); $self->hangup(); my $result = $self->send_init_string(); $self->_reset_flags(); return $result; } # Return an hash with the status of main modem signals sub status { my $self = shift; $self->log->write('info', 'getting modem line status on '.$self->{'port'}); # This also relies on Device::SerialPort my $status = $self->port->modemlines(); # See top of module for these constants, exported by (Win32|Device)::SerialPort my %signal = ( CTS => $status & Device::Modem::MS_CTS_ON, DSR => $status & Device::Modem::MS_DSR_ON, RING => $status & Device::Modem::MS_RING_ON, RLSD => $status & Device::Modem::MS_RLSD_ON ); $self->log->write('info', 'modem on '.$self->{'port'}.' status is ['.$status.']'); $self->log->write('info', "CTS=$signal{CTS} DSR=$signal{DSR} RING=$signal{RING} RLSD=$signal{RLSD}"); return %signal; } # Of little use here, but nice to have it # restore_factory_settings( profile ) # profile can be 0 or 1 sub restore_factory_settings { my $self = shift; my $profile = shift; $profile = 0 unless defined $profile; $self->log->write('warning', 'restoring factory settings '.$profile.' on '.$self->{'port'} ); $self->atsend( 'AT&F'.$profile . CR); $self->answer($Device::Modem::STD_RESPONSE); } # Store telephone number in modem's internal address book, to dial later # store_number( position, number ) sub store_number { my( $self, $position, $number ) = @_; my $ok = 0; # Check parameters unless( defined($position) && $number ) { $self->log->write('warning', 'store_number() called with wrong parameters'); return $ok; } $self->log->write('info', 'storing number ['.$number.'] into memory ['.$position.']'); # Remove all non-numerical chars from position and number $position =~ s/\D//g; $number =~ s/[^0-9,]//g; $self->atsend( sprintf( 'AT &Z%d=%s' . CR, $position, $number ) ); if( index( $self->answer(), 'OK' ) != -1 ) { $self->log->write('info', 'stored number ['.$number.'] into memory ['.$position.']'); $ok = 1; } else { $self->log->write('warning', 'error storing number ['.$number.'] into memory ['.$position.']'); $ok = 0; } return $ok; } # Enable/disable verbose response messages against numerical response messages # XXX I need to manage also numerical values... sub verbose { my($self, $lEnable) = @_; $self->log->write( 'info', ( $lEnable ? 'enabling' : 'disabling' ) . ' verbose messages' ); $self->atsend( ($lEnable ? 'ATQ0V1' : 'ATQ0V0') . CR ); $self->answer($Device::Modem::STD_RESPONSE); } sub wait { my( $self, $msec ) = @_; $self->log->write('debug', 'waiting for '.$msec.' msecs'); # Perhaps Time::HiRes here is not so useful, since I tested `select()' system call also on Windows select( undef, undef, undef, $msec / 1000 ); return 1; } # Set a named flag. Flags are now: OFFHOOK, CARRIER sub flag { my $self = shift; my $cFlag = uc shift; $self->{'_flags'}->{$cFlag} = shift() if @_; $self->{'_flags'}->{$cFlag}; } # reset internal flags that tell the status of modem (XXX to be extended) sub _reset_flags { my $self = shift(); map { $self->flag($_, 0) } 'OFFHOOK', 'CARRIER'; } # initialize modem with some basic commands (XXX &C0) # send_init_string( [my_init_string] ) # my_init_string goes without 'AT' prefix sub send_init_string { my($self, $cInit) = @_; $cInit = $self->options->{'init_string'} unless defined $cInit; # If no Init string then do nothing! if ($cInit) { $self->attention(); $self->atsend('AT '.$cInit. CR ); return $self->answer($Device::Modem::STD_RESPONSE); } } # returns log object reference or nothing if it is not defined sub log { my $me = shift; if( ref $me->{'_log'} ) { return $me->{'_log'}; } else { return {}; } } # instances (Device|Win32)::SerialPort object and initializes communications sub connect { my $me = shift(); my %aOpt = (); if( @_ ) { %aOpt = @_; } my $lOk = 0; # Set default values if missing $aOpt{'baudrate'} ||= $Device::Modem::BAUDRATE; $aOpt{'databits'} ||= $Device::Modem::DATABITS; $aOpt{'parity'} ||= $Device::Modem::PARITY; $aOpt{'stopbits'} ||= $Device::Modem::STOPBITS; $aOpt{'handshake'}||= $Device::Modem::HANDSHAKE; $aOpt{'max_reset_iter'} ||= 0; # Store communication options in object $me->{'_comm_options'} = \%aOpt; # Connect on serial (use different mod for win32) if( $me->ostype eq 'windoze' ) { $me->port( new Win32::SerialPort($me->{'port'}) ); } else { $me->port( new Device::SerialPort($me->{'port'}) ); } # Check connection unless( ref $me->port ) { $me->log->write( 'err', '*FAILED* connect on '.$me->{'port'} ); return $lOk; } # Set communication options my $oPort = $me->port; $oPort -> baudrate ( $me->options->{'baudrate'} ); $oPort -> databits ( $me->options->{'databits'} ); $oPort -> stopbits ( $me->options->{'stopbits'} ); $oPort -> parity ( $me->options->{'parity'} ); $oPort -> handshake( $me->options->{'handshake'} ); # Non configurable options $oPort -> buffers ( 10000, 10000 ); $oPort -> read_const_time ( 20 ); # was 500 $oPort -> read_char_time ( 0 ); # read_interval() seems to be unsupported on Device::SerialPort, # while allowed on Win32::SerialPort... if( $oPort->can('read_interval') ) { $oPort->read_interval( 20 ); } $oPort -> are_match ( 'OK' ); $oPort -> lookclear; unless ( $oPort -> write_settings ) { $me->log->write('err', '*FAILED* write_settings on '.$me->{'port'} ); return $lOk; } $oPort -> purge_all; # Get the modems attention # Send multiple reset commands looking for a sensible response. # A small number of modems need time to settle down and start responding to the serial port my $iter = 0; my $ok = 0; my $blank = 0; while ( ($iter < $aOpt{'max_reset_iter'}) && ($ok < 2) && ($blank < 3) ) { $me->atsend('AT E0'. CR ); my $rslt = $me->answer($Device::Modem::STD_RESPONSE, 1500); # print "Res: $rslt \r\n"; $iter+=1; if ($rslt && $rslt =~ /^OK/) { $ok+=1; } else { $ok=0; } if (!$rslt) { $blank++; } else { $blank=0; } } if ($aOpt{'max_reset_iter'}) { $me->log->write('debug', "DEBUG CONNECT: $iter : $ok : $blank\n"); # DEBUG } $me-> log -> write('info', 'sending init string...' ); # Set default initialization string if none supplied my $init_string = defined $me->options->{'init_string'} ? $me->options->{'init_string'} : $Device::Modem::DEFAULT_INIT_STRING; my $init_response = $me->send_init_string($init_string) || ''; $me-> log -> write('debug', "init response: $init_response\n"); # DEBUG $me-> _reset_flags(); # Disable local echo $me-> echo(0); $me-> log -> write('info', 'Ok connected' ); $me-> {'CONNECTED'} = 1; } # $^O is stored into object sub ostype { my $self = shift; $self->{'ostype'}; } # returns Device::SerialPort reference to hash options sub options { my $self = shift(); @_ ? $self->{'_comm_options'} = shift() : $self->{'_comm_options'}; } # returns Device::SerialPort object handle sub port { my $self = shift; if (@_) { return ($self->{'_comm_object'} = shift); } my $port_obj = $self->{'_comm_object'}; # Maybe the port was disconnected? if (defined $self->{'CONNECTED'} && $self->{'CONNECTED'} == 1 && # We were connected (! defined $port_obj || ! $port_obj)) { # Now we aren't anymore # Avoid recursion on ourselves $self->{'CONNECTED'} = 0; # Try to reconnect if possible my $connect_options = $self->options; # No connect options probably because we didn't ever connect if (! $connect_options) { Carp::croak("Not connected"); } $self->connect(%{ $connect_options }); $port_obj = $self->{'_comm_object'}; } # Still not connected? bail out if (! defined $port_obj || ! $port_obj) { Carp::croak("Not connected"); } return $port_obj; } # disconnect serial port sub disconnect { my $me = shift; $me->port->close(); $me->log->write('info', 'Disconnected from '.$me->{'port'} ); } # Send AT command to device on serial port (command must include CR for now) sub atsend { my( $me, $msg ) = @_; my $cnt = 0; # Write message on port $me->port->purge_all(); $cnt = $me->port->write($msg); my $lbuf=length($msg); my $ret; while ($cnt < $lbuf) { $ret = $me->port->write(substr($msg, $cnt)); $me->write_drain(); last unless defined $ret; $cnt += $ret; } $me->log->write('debug', 'atsend: wrote '.$cnt.'/'.length($msg).' chars'); # If wrote all chars of `msg', we are successful return $cnt == length $msg; } # Call write_drain() if platform allows to (no call for Win32) sub write_drain { my $me = shift; # No write_drain() call for win32 systems return if $me->ostype eq 'windoze'; # No write_drain() if no port object available my $port = $me->port; return unless $port; return $port->write_drain(); } # answer() takes strings from the device until a pattern # is encountered or a timeout happens. sub _answer { my $me = shift; my($expect, $timeout) = @_; $expect = $Device::Modem::STD_RESPONSE if (! defined($expect)); $timeout = $Device::Modem::TIMEOUT if (! defined($timeout)); # If we expect something, we must first match against serial input my $done = (defined $expect and $expect ne ''); $me->log->write('debug', 'answer: expecting ['.($expect||'').']'.($timeout ? ' or '.($timeout/1000).' seconds timeout' : '' ) ); # Main read cycle my $cycles = 0; my $idle_cycles = 0; my $answer; my $start_time = time(); my $end_time = 0; # If timeout was defined, check max time (timeout is in milliseconds) $me->log->write('debug', 'answer: timeout value is '.($timeout||'undef')); if( defined $timeout && $timeout > 0 ) { $end_time = $start_time + ($timeout / 1000); $end_time++ if $end_time == $start_time; $me->log->write( debug => 'answer: end time set to '.$end_time ); } do { my ($what, $howmany); $what = $me->port->read(1) . $me->port->input; $howmany = length($what); # Timeout count incremented only on empty readings if( defined $what && $howmany > 0 ) { # Add received chars to answer string $answer .= $what; # Check if buffer matches "expect string" if( defined $expect ) { my $copy = $answer; $copy =~ s/\r(\n)?/\n/g; # Convert line endings from "\r" or "\r\n" to "\n" $done = ( defined $copy && $copy =~ $expect ) ? 1 : 0; $me->log->write( debug => 'answer: matched expect: '.$expect ) if ($done); } # Check if we reached max time for timeout (only if end_time is defined) } elsif( $end_time > 0 ) { $done = (time >= $end_time) ? 1 : 0; # Read last chars in read queue if( $done ) { $me->log->write('info', 'reached timeout max wait without response'); } # Else we have done } else { $done = 1; } $me->log->write('debug', 'done='.$done.' end='.$end_time.' now='.time().' start='.$start_time ); } while (not $done); $me->log->write('info', 'answer: read ['.($answer||'').']' ); # Flush receive and trasmit buffers $me->port->purge_all; return $answer; } sub answer { my $me = shift(); my $answer = $me->_answer(@_); # Trim result of beginning and ending CR+LF (XXX) if( defined $answer ) { $answer =~ s/^[\r\n]+//; $answer =~ s/[\r\n]+$//; } $me->log->write('info', 'answer: `'.($answer||'').'\'' ); return $answer; } # parse_answer() cleans out answer() result as response code + # useful information (useful in informative commands, for example # Gsm command AT+CGMI) sub parse_answer { my $me = shift; my $buff = $me->answer( @_ ); # Separate response code from information if( defined $buff && $buff ne '' ) { my @buff = split /[\r\n]+/o, $buff; # Remove all empty lines before/after response shift @buff while $buff[0] =~ /^[\r\n]+/o; pop @buff while $buff[-1] =~ /^[\r\n]+/o; # Extract responde code $buff = join( CR, @buff ); my $code = pop @buff; return wantarray ? ($code, @buff) : $buff; } else { return ''; } } 1; =head1 NAME Device::Modem - Perl extension to talk to modem devices connected via serial port =head1 WARNING This is B software, so use it at your own risk, and without B warranty! Have fun. =head1 SYNOPSIS use Device::Modem; my $modem = new Device::Modem( port => '/dev/ttyS1' ); if( $modem->connect( baudrate => 9600 ) ) { print "connected!\n"; } else { print "sorry, no connection with serial port!\n"; } $modem->attention(); # send `attention' sequence (+++) ($ok, $answer) = $modem->dial('02270469012'); # dial phone number $ok = $modem->dial(3); # 1-digit parameter = dial number stored in memory 3 $modem->echo(1); # enable local echo (0 to disable) $modem->offhook(); # Take off hook (ready to dial) $modem->hangup(); # returns modem answer $modem->is_active(); # Tests whether modem device is active or not # So far it works for modem OFF/ modem ON condition $modem->reset(); # hangup + attention + restore setting 0 (Z0) $modem->restore_factory_settings(); # Handle with care! $modem->restore_factory_settings(1); # Same with preset profile 1 (can be 0 or 1) $modem->send_init_string(); # Send initialization string # Now this is fixed to 'AT H0 Z S7=45 S0=0 Q0 V1 E0 &C0 X4' # Get/Set value of S1 register my $S1 = $modem->S_register(1); my $S1 = $modem->S_register(1, 55); # Don't do that if you definitely don't know! # Get status of managed signals (CTS, DSR, RLSD, RING) my %signal = $modem->status(); if( $signal{DSR} ) { print "Data Set Ready signal active!\n"; } # Stores this number in modem memory number 3 $modem->store_number(3, '01005552817'); $modem->repeat(); # Repeat last command $modem->verbose(1); # Normal text responses (0=numeric codes) # Some raw AT commands $modem->atsend( 'ATH0' ); print $modem->answer(); $modem->atsend( 'ATDT01234567' . Device::Modem::CR ); print $modem->answer(); =head1 DESCRIPTION C class implements basic B device abstraction. It can be inherited by sub classes (as C), which are based on serial connections. =head2 Things C can do =over 4 =item * connect to a modem on your serial port =item * test if the modem is alive and working =item * dial a number and connect to a remote modem =item * work with registers and settings of the modem =item * issue standard or arbitrary C commands, getting results from modem =back =head2 Things C can't do yet =over 4 =item * Transfer a file to a remote modem =item * Control a terminal-like (or a PPP) connection. This should really not be very hard to do anyway. =item * Many others... =back =head2 Things it will never be able to do =over 4 =item * Coffee :-) =back =head2 Examples In the `examples' directory, there are some scripts that should work without big problems, that you can take as (yea) examples: =over 4 =item `examples/active.pl' Tests if modem is alive =item `examples/caller-id.pl' Waits for an incoming call and displays date, time and phone number of the caller. Normally this is available everywhere, but you should check your local phone line and settings. =item `examples/dial.pl' Dials a phone number and display result of call =item `examples/shell.pl' (Very) poor man's minicom/hyperterminal utility =item `examples/xmodem.pl' First attempt at a test script to receive a file via xmodem protocol. Please be warned that this thing does not have a chance to work. It's only a (very low priority) work in progress... If you want to help out, be welcome! =back =head1 METHODS =head2 answer() One of the most used methods, waits for an answer from the device. It waits until $timeout (seconds) is reached (but don't rely on this time to be very correct) or until an expected string is encountered. Example: $answer = $modem->answer( [$expect [, $timeout]] ) Returns C<$answer> that is the string received from modem stripped of all B and B chars B at the beginning and at the end of the string. No in-between B are stripped. Note that if you need the raw answer from the modem, you can use the _answer() (note that underscore char before answer) method, which does not strip anything from the response, so you get the real modem answer string. Parameters: =over 4 =item * C<$expect> - Can be a regexp compiled with C or a simple substring. Input coming from the modem is matched against this parameter. If input matches, result is returned. =item * C<$timeout> - Expressed in milliseconds. After that time, answer returns result also if nothing has been received. Example: C<10000>. Default: C<$Device::Modem::TIMEOUT>, currently 500 ms. =back =head2 atsend() Sends a raw C command to the device connected. Note that this method is most used internally, but can be also used to send your own custom commands. Example: $ok = $modem->atsend( $msg ) The only parameter is C<$msg>, that is the raw AT command to be sent to modem expressed as string. You must include the C prefix and final B and/or B manually. There is the special constant C that can be used to include such a char sequence into the at command. Returns C<$ok> flag that is true if all characters are sent successfully, false otherwise. Example: # Enable verbose messages $modem->atsend( 'AT V1' . Device::Modem::CR ); # The same as: $modem->verbose(1); =head2 attention() This command sends an B sequence to modem. This allows modem to pass in B and accept B commands. Example: $ok = $modem->attention() =head2 connect() Connects C object to the specified serial port. There are options (the same options that C has) to control the parameters associated to serial link. Example: $ok = $modem->connect( [%options] ) List of allowed options follows: =over 4 =item C Controls the speed of serial communications. The default is B<19200> baud, that should be supported by all modern modems. However, here you can supply a custom value. Common speed values: 300, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200. This parameter is handled directly by C object. =item C This tells how many bits your data word is composed of. Default (and most common setting) is C<8>. This parameter is handled directly by C object. =item C Sets the handshake (or flow control) method for the serial port. By default it is C, but can be either C (hardware flow control) or C (software flow control). These flow control modes may or may not work depending on your modem device or software. =item C Custom initialization string can be supplied instead of the built-in one, that is the following: C, that is taken shamelessly from C utility, I think. =item C Controls how parity bit is generated and checked. Can be B, B or B. Default is B. This parameter is handled directly by C object. =item C Tells how many bits are used to identify the end of a data word. Default (and most common usage) is C<1>. This parameter is handled directly by C object. =back =head2 dial() Dials a telephone number. Can perform both voice and data calls. Usage: $ok = $modem->dial($number); $ok = $modem->dial($number, $timeout); $ok = $modem->dial($number, $timeout, $mode); Takes the modem off hook, dials the specified number and returns modem answer. Regarding voice calls, you B be able to send your voice through. You probably have to connect an analog microphone, and just speak. Or use a GSM phone. For voice calls, a simple C<;> is appended to the number to be dialed. If the number to dial is 1 digit only, extracts the number from the address book, provided your device has one. See C. Examples: # Simple usage. Timeout and mode are optional. $ok = $mode->dial('123456789'); # List context: allows to get at exact modem answer # like `CONNECT 19200/...', `BUSY', `NO CARRIER', ... # Also, 30 seconds timeout ($ok, $answer) = $modem->dial('123456789', 30); If called in B, returns only success of connection. If modem answer contains the C string, C returns successful state, otherwise a false value is returned. If called in B, returns the same C<$ok> flag, but also the exact modem answer to the dial operation in the C<$answer> scalar. C<$answer> typically can contain strings like: =over 4 =item C =item C =item C =back and so on ... all standard modem answers to a dial command. Parameters are: =over 4 =item C<$number> B, this is the phone number to dial. If C<$number> is only 1 digit, it is interpreted as: B>. So if your code is: $modem->dial( 2, 10 ); This means: dial number in the modem internal address book (see C for a way to read/write address book) in position number B<2> and wait for a timeout of B<10> seconds. =item C<$timeout> B, default is B<30 seconds>. Timeout expressed in seconds to wait for the remote device to answer. Please do not expect an B wait for the number of seconds you specified. =item C<$mode> B, default is C, as string. Allows to specify the type of call. Can be either: =over 4 =item C (default) To perform a B. =item C To perform a B, if your device supports it. No attempt to verify whether your device can do that will be made. =back =back =head2 disconnect() Disconnects C object from serial port. This method calls underlying C of C object. Example: $modem->disconnect(); =head2 echo() Enables or disables local echo of commands. This is managed automatically by C object. Normally you should not need to worry about this. Usage: $ok = $modem->echo( $enable ) =head2 hangup() Does what it is supposed to do. Hang up the phone thus terminating any active call. Usage: $ok = $modem->hangup(); =head2 is_active() Can be used to check if there is a modem attached to your computer. If modem is alive and responding (on serial link, not to a remote call), C returns true (1), otherwise returns false (0). Test of modem activity is done through DSR (Data Set Ready) signal. If this signal is in off state, modem is probably turned off, or not working. From my tests I've found that DSR stays in "on" state after more or less one second I turn off my modem, so know you know that. Example: if( $modem->is_active() ) { # Ok! } else { # Modem turned off? } =head2 log() Simple accessor to log object instanced at object creation time. Used internally. If you want to know the gory details, see C objects. You can also see the B for how to log something without knowing all the gory details. Hint: $modem->log->write('warning', 'ok, my log message here'); =head2 new() C constructor. This takes several options. A basic example: my $modem = Device::Modem->new( port => '/dev/ttyS0' ); if under Linux or some kind of unix machine, or my $modem = Device::Modem->new( port => 'COM1' ); if you are using a Win32 machine. This builds the C object with all the default parameters. This should be fairly usable if you want to connect to a real modem. Note that I'm testing it with a B<3Com US Robotics 56K Message> modem at B<19200> baud and works ok. List of allowed options: =over 4 =item * C - serial port to connect to. On Unix, can be also a convenient link as F (the default value). For Win32, C can be used. =item * C - this specifies the method and eventually the filename for logging. Logging process with C is controlled by B, stored under F folder. At present, there are two main plugins: C and C. C does not work with Win32 machines. When using C plug-in, all log information will be written to a default filename if you don't specify one yourself. The default is F<%WINBOOTDIR%\temp\modem.log> on Win32 and F on Unix. Also there is the possibility to pass a B, if this object provides the following C call: $log_object->write( $loglevel, $logmessage ) You can simply pass this object (already instanced) as the C property. Examples: # For Win32, default is to log in "%WINBOOTDIR%/temp/modem.log" file my $modem = Device::Modem->new( port => 'COM1' ); # Unix, custom logfile my $modem = Device::Modem->new( port => '/dev/ttyS0', log => 'file,/home/neo/matrix.log' ) # With custom log object my $modem = Device::modem->new( port => '/dev/ttyS0', log => My::LogObj->new() ); =item * C - default logging level. One of (order of decrescent verbosity): C, C, C, C, C, C, C, C, C. =back =head2 offhook() Takes the modem "off hook", ready to dial. Normally you don't need to use this. Also C goes automatically off hook before dialing. =head2 parse_answer() This method works like C, it accepts the same parameters, but it does not return the raw modem answer. Instead, it returns the answer string stripped of all B/B characters at the beginning B at the end. C is meant as an easy way of extracting result code (C, C, ...) and information strings that can be sent by modem in response to specific commands. Example: > AT xSHOW_MODELx US Robotics 56K Message OK > In this example, C is the result and C is the informational message. In fact, another difference with C is in the return value(s). Here are some examples: $modem->atsend( '?my_at_command?' ); $answer = $modem->parse_answer(); where C<$answer> is the complete response string, or: ($result, @lines) = $modem->parse_answer(); where C<$result> is the C or C final message and C<@lines> is the array of information messages (one or more lines). For the I example, C<$result> would hold "C" and C<@lines> would consist of only 1 line with the string "C". =head2 port() Used internally. Accesses the C underlying object. If you need to experiment or do low-level serial calls, you may want to access this. Please report any usage of this kind, because probably (?) it is possible to include it in a higher level method. As of 1.52, C will automatically try to reconnect if it detects a bogus underlying port object. It will reconnect with the same options used when Cing the first time. If no connection has taken place yet, then B will be attempted. =head2 repeat() Repeats the last C command issued. Usage: $ok = $modem->repeat() =head2 reset() Tries in any possible way to reset the modem to the starting state, hanging up all active calls, resending the initialization string and preparing to receive C commands. =head2 restore_factory_settings() Restores the modem default factory settings. There are normally two main "profiles", two different memories for all modem settings, so you can load profile 0 and profile 1, that can be different depending on your modem manufacturer. Usage: $ok = $modem->restore_factory_settings( [$profile] ) If no C<$profile> is supplied, C<0> is assumed as default value. Check on your modem hardware manual for the meaning of these B. =head2 S_register() Gets or sets an B value. These are some internal modem registers that hold important information that controls all modem behaviour. If you don't know what you are doing, don't use this method. Usage: $value = $modem->S_register( $reg_number [, $new_value] ); C<$reg_number> ranges from 0 to 99 (sure?). If no C<$new_value> is supplied, return value is the current register value. If a C<$new_value> is supplied (you want to set the register value), return value is the new value or C if there was an error setting the new value. Examples: # Get value of S7 register $modem->S_register(7); # Set value of S0 register to 0 $modem->S_register(0, 0); =head2 send_init_string() Sends the initialization string to the connected modem. Usage: $ok = $modem->send_init_string( [$init_string] ); If you specified an C as an option to C object constructor, that is taken by default to initialize the modem. Else you can specify C<$init_string> parameter to use your own custom intialization string. Be careful! =head2 status() Returns status of main modem signals as managed by C (or C) objects. The signals reported are: =over 4 =item CTS Clear to send =item DSR Data set ready =item RING Active if modem is ringing =item RLSD ??? Released line ??? =back Return value of C call is a hash, where each key is a signal name and each value is > 0 if signal is active, 0 otherwise. Usage: ... my %sig = $modem->status(); for ('CTS','DSR','RING','RLSD') { print "Signal $_ is ", ($sig{$_} > 0 ? 'on' : 'off'), "\n"; } =head2 store_number() Store telephone number in modem internal address book, to be dialed later (see C method). Usage: $ok = $modem->store_number( $position, $number ) where C<$position> is the address book memory slot to store phone number (usually from 0 to 9), and C<$number> is the number to be stored in the slot. Return value is true if operation was successful, false otherwise. =head2 verbose() Enables or disables verbose messages. This is managed automatically by C object. Normally you should not need to worry about this. Usage: $ok = $modem->verbose( $enable ) =head2 wait() Waits (yea) for a given amount of time (in milliseconds). Usage: $modem->wait( [$msecs] ) Wait is implemented via C