Constructors

  # $lockfile is optional
  $PortObj = new Device::SerialPort ($PortName, $quiet, $lockfile)
       || die "Can't open $PortName: $!\n";

  $PortObj = start Device::SerialPort ($Configuration_File_Name)
       || die "Can't start $Configuration_File_Name: $!\n";

  $PortObj = tie (*FH, 'Device::SerialPort', $Configuration_File_Name)
       || die "Can't tie using $Configuration_File_Name: $!\n";

Configuration Utility Methods

  $PortObj->alias("MODEM1");

  $PortObj->save($Configuration_File_Name)
       || warn "Can't save $Configuration_File_Name: $!\n";

  # currently optional after new, POSIX version expected to succeed
  $PortObj->write_settings;

  # rereads file to either return open port to a known state
  # or switch to a different configuration on the same port
  $PortObj->restart($Configuration_File_Name)
       || warn "Can't reread $Configuration_File_Name: $!\n";

  # "app. variables" saved in $Configuration_File, not used internally
  $PortObj->devicetype('none');     # CM11, CM17, 'weeder', 'modem'
  $PortObj->hostname('localhost');  # for socket-based implementations
  $PortObj->hostaddr(0);            # false unless specified
  $PortObj->datatype('raw');        # in case an application needs_to_know
  $PortObj->cfg_param_1('none');    # null string '' hard to save/restore
  $PortObj->cfg_param_2('none');    # 3 spares should be enough for now
  $PortObj->cfg_param_3('none');    # one may end up as a log file path

  # test suite use only
  @necessary_param = Device::SerialPort->set_test_mode_active(1);

  # exported by :PARAM
  nocarp || carp "Something fishy";
  $a = SHORTsize;                       # 0xffff
  $a = LONGsize;                        # 0xffffffff
  $answer = yes_true("choice");         # 1 or 0
  OS_Error unless ($API_Call_OK);       # prints error

Configuration Parameter Methods

  # most methods can be called two ways:
  $PortObj->handshake("xoff");           # set parameter
  $flowcontrol = $PortObj->handshake;    # current value (scalar)

  # The only "list context" method calls from Win32::SerialPort
  # currently supported are those for baudrate, parity, databits,
  # stopbits, and handshake (which only accept specific input values).
  @handshake_opts = $PortObj->handshake; # permitted choices (list)

  # similar
  $PortObj->baudrate(9600);
  $PortObj->parity("odd");
  $PortObj->databits(8);
  $PortObj->stopbits(1);        # POSIX does not support 1.5 stopbits

  # these are essentially dummies in POSIX implementation
  # the calls exist to support compatibility
  $PortObj->buffers(4096, 4096);        # returns (4096, 4096)
  @max_values = $PortObj->buffer_max;   # returns (4096, 4096)
  $PortObj->reset_error;                # returns 0

  # true/false parameters (return scalar context only)
  # parameters exist, but message processing not yet fully implemented
  $PortObj->user_msg(ON);       # built-in instead of warn/die above
  $PortObj->error_msg(ON);      # translate error bitmasks and carp

  $PortObj->parity_enable(F);   # faults during input
  $PortObj->debug(0);

  # true/false capabilities (read only)
  # most are just constants in the POSIX case
  $PortObj->can_baud;                   # 1
  $PortObj->can_databits;               # 1
  $PortObj->can_stopbits;               # 1
  $PortObj->can_dtrdsr;                 # 1
  $PortObj->can_handshake;              # 1
  $PortObj->can_parity_check;           # 1
  $PortObj->can_parity_config;          # 1
  $PortObj->can_parity_enable;          # 1
  $PortObj->can_rlsd;                   # 0 currently
  $PortObj->can_16bitmode;              # 0 Win32-specific
  $PortObj->is_rs232;                   # 1
  $PortObj->is_modem;                   # 0 Win32-specific
  $PortObj->can_rtscts;                 # 1
  $PortObj->can_xonxoff;                # 1
  $PortObj->can_xon_char;               # 1 use stty
  $PortObj->can_spec_char;              # 0 use stty
  $PortObj->can_interval_timeout;       # 0 currently
  $PortObj->can_total_timeout;          # 1 currently
  $PortObj->can_ioctl;                  # automatically detected
  $PortObj->can_status;                 # automatically detected
  $PortObj->can_write_done;             # automatically detected
  $PortObj->can_modemlines;     # automatically detected
  $PortObj->can_wait_modemlines;# automatically detected
  $PortObj->can_intr_count;             # automatically detected
  $PortObj->can_arbitrary_baud; # automatically detected

Operating Methods

  ($count_in, $string_in) = $PortObj->read($InBytes);
  warn "read unsuccessful\n" unless ($count_in == $InBytes);

  $count_out = $PortObj->write($output_string);
  warn "write failed\n"         unless ($count_out);
  warn "write incomplete\n"     if ( $count_out != length($output_string) );

  if ($string_in = $PortObj->input) { PortObj->write($string_in); }
     # simple echo with no control character processing

  if ($PortObj->can_wait_modemlines) {
    $rc = $PortObj->wait_modemlines( MS_RLSD_ON );
    if (!$rc) { print "carrier detect changed\n"; }
  }

  if ($PortObj->can_modemlines) {
    $ModemStatus = $PortObj->modemlines;
    if ($ModemStatus & $PortObj->MS_RLSD_ON) { print "carrier detected\n"; }
  }

  if ($PortObj->can_intr_count) {
    $count = $PortObj->intr_count();
    print "got $count interrupts\n";
  }

  if ($PortObj->can_arbitrary_baud) {
    print "this port can set arbitrary baud rates\n";
  }

  ($BlockingFlags, $InBytes, $OutBytes, $ErrorFlags) = $PortObj->status;
      # same format for compatibility. Only $InBytes and $OutBytes are
      # currently returned (on linux). Others are 0.
      # Check return value of "can_status" to see if this call is valid.

  ($done, $count_out) = $PortObj->write_done(0);
     # POSIX defaults to background write. Currently $count_out always 0.
     # $done set when hardware finished transmitting and shared line can
     # be released for other use. Ioctl may not work on all OSs.
     # Check return value of "can_write_done" to see if this call is valid.

  $PortObj->write_drain;  # POSIX alternative to Win32 write_done(1)
                          # set when software is finished transmitting
  $PortObj->purge_all;
  $PortObj->purge_rx;
  $PortObj->purge_tx;

      # controlling outputs from the port
  $PortObj->dtr_active(T);              # sends outputs direct to hardware
  $PortObj->rts_active(Yes);            # return status of ioctl call
                                        # return undef on failure

  $PortObj->pulse_break_on($milliseconds); # off version is implausible
  $PortObj->pulse_rts_on($milliseconds);
  $PortObj->pulse_rts_off($milliseconds);
  $PortObj->pulse_dtr_on($milliseconds);
  $PortObj->pulse_dtr_off($milliseconds);
      # sets_bit, delays, resets_bit, delays
      # returns undef if unsuccessful or ioctls not implemented

  $PortObj->read_const_time(100);       # const time for read (milliseconds)
  $PortObj->read_char_time(5);          # avg time between read char

  $milliseconds = $PortObj->get_tick_count;

Methods used with Tied FileHandles

  $PortObj = tie (*FH, 'Device::SerialPort', $Configuration_File_Name)
       || die "Can't tie: $!\n";             ## TIEHANDLE ##

  print FH "text";                           ## PRINT     ##
  $char = getc FH;                           ## GETC      ##
  syswrite FH, $out, length($out), 0;        ## WRITE     ##
  $line = <FH>;                              ## READLINE  ##
  @lines = <FH>;                             ## READLINE  ##
  printf FH "received: %s", $line;           ## PRINTF    ##
  read (FH, $in, 5, 0) or die "$!";          ## READ      ##
  sysread (FH, $in, 5, 0) or die "$!";       ## READ      ##
  close FH || warn "close failed";           ## CLOSE     ##
  undef $PortObj;
  untie *FH;                                 ## DESTROY   ##

  $PortObj->linesize(10);                    # with READLINE
  $PortObj->lastline("_GOT_ME_");            # with READLINE, list only

      ## with PRINT and PRINTF, return previous value of separator
  $old_ors = $PortObj->output_record_separator("RECORD");
  $old_ofs = $PortObj->output_field_separator("COMMA");

Destructors

  $PortObj->close || warn "close failed";
      # release port to OS - needed to reopen
      # close will not usually DESTROY the object
      # also called as: close FH || warn "close failed";

  undef $PortObj;
      # preferred unless reopen expected since it triggers DESTROY
      # calls $PortObj->close but does not confirm success
      # MUST precede untie - do all three IN THIS SEQUENCE before re-tie.

  untie *FH;

Methods for I/O Processing

  $PortObj->are_match("text", "\n");    # possible end strings
  $PortObj->lookclear;                  # empty buffers
  $PortObj->write("Feed Me:");          # initial prompt
  $PortObj->is_prompt("More Food:");    # not implemented

  my $gotit = "";
  until ("" ne $gotit) {
      $gotit = $PortObj->lookfor;       # poll until data ready
      die "Aborted without match\n" unless (defined $gotit);
      sleep 1;                          # polling sample time
  }

  printf "gotit = %s\n", $gotit;                # input BEFORE the match
  my ($match, $after, $pattern, $instead) = $PortObj->lastlook;
      # input that MATCHED, input AFTER the match, PATTERN that matched
      # input received INSTEAD when timeout without match
  printf "lastlook-match = %s  -after = %s  -pattern = %s\n",
                           $match,      $after,        $pattern;

  $gotit = $PortObj->lookfor($count);   # block until $count chars received

  $PortObj->are_match("-re", "pattern", "text");
      # possible match strings: "pattern" is a regular expression,
      #                         "text" is a literal string

Initialization

  $PortObj = new Device::SerialPort ($PortName, $quiet, $lockfile)
       || die "Can't open $PortName: $!\n";

The $quiet parameter is ignored and is only there for compatibility with Win32::SerialPort. The $lockfile parameter is optional. It will attempt to create a file (containing just the current process id) at the location specified. This file will be automatically deleted when the $PortObj is no longer used (by DESTROY). You would usually request $lockfile with $quiet true to disable messages while attempting to obtain exclusive ownership of the port via the lock. Lockfiles are experimental in Version 0.07. They are intended for use with other applications. No attempt is made to resolve port aliases (/dev/modem == /dev/ttySx) or to deal with login processes such as getty and uugetty.

Using a Configuration File with new or by using second constructor, start, scripts can be simplified if they need a constant setup. It executes all the steps from new to write_settings based on a previously saved configuration. This constructor will return "undef" on a bad configuration file or failure of a validity check. The returned object is ready for access. This is new and experimental for Version 0.055.

  $PortObj2 = start Device::SerialPort ($Configuration_File_Name)
       || die;

The third constructor, tie, will combine the start with Perl's support for tied FileHandles (see perltie). Device::SerialPort will implement the complete set of methods: TIEHANDLE, PRINT, PRINTF, WRITE, READ, GETC, READLINE, CLOSE, and DESTROY. Tied FileHandle support is new with Version 0.04 and the READ and READLINE methods were added in Version 0.06. In "scalar context", READLINE sets stty_icanon to do character processing and calls lookfor. It restores stty_icanon after the read. In "list context", READLINE does Canonical (line) reads if stty_icanon is set or calls streamline if it is not. (stty_icanon is not altered). The streamline choice allows duplicating the operation of Win32::SerialPort for cross-platform scripts.

The implementation attempts to mimic STDIN/STDOUT behaviour as closely as possible: calls block until done and data strings that exceed internal buffers are divided transparently into multiple calls. In Version 0.06, the output separators $, and "$\" are also applied to PRINT if set. The output_record_separator and output_field_separator methods can set Port-FileHandle-Specific versions of $, and "$\" if desired. Since PRINTF is treated internally as a single record PRINT, "$\" will be applied. Output separators are not applied to WRITE (called as "syswrite FH, $scalar, $length, [$offset]"). The input_record_separator $/ is not explicitly supported - but an identical function can be obtained with a suitable are_match setting.

  $PortObj2 = tie (*FH, 'Device::SerialPort', $Configuration_File_Name)
       || die;

The tied FileHandle methods may be combined with the Device::SerialPort methods for read, input, and write as well as other methods. The typical restrictions against mixing print with syswrite do not apply. Since both (tied) read and sysread call the same "$ob->READ" method, and since a separate "$ob->read" method has existed for some time in Device::SerialPort, you should always use sysread with the tied interface (when it is implemented).

Some individual parameters (eg. baudrate) can be changed after the initialization is completed. These will be validated and will update the serial driver as required. The save method will write the current parameters to a file that start, tie, and restart can use to reestablish a functional setup.

  $PortObj = new Win32::SerialPort ($PortName, $quiet)
       || die "Can't open $PortName: $^E\n";    # $quiet is optional

  $PortObj->user_msg(ON);
  $PortObj->databits(8);
  $PortObj->baudrate(9600);
  $PortObj->parity("none");
  $PortObj->stopbits(1);
  $PortObj->handshake("rts");

  $PortObj->write_settings || undef $PortObj;

  $PortObj->save($Configuration_File_Name);
  $PortObj->baudrate(300);
  $PortObj->restart($Configuration_File_Name);  # back to 9600 baud

  $PortObj->close || die "failed to close";
  undef $PortObj;                               # frees memory back to perl

Configuration Utility Methods

  $PortObj->alias("MODEM1");

Starting in Version 0.07, a number of Application Variables are saved in $Configuration_File. These parameters are not used internally. But methods allow setting and reading them. The intent is to facilitate the use of separate configuration scripts to create the files. Then an application can use start as the Constructor and not bother with command line processing or managing its own small configuration file. The default values and number of parameters is subject to change.

  $PortObj->devicetype('none'); 
  $PortObj->hostname('localhost');  # for socket-based implementations
  $PortObj->hostaddr(0);            # a "false" value
  $PortObj->datatype('raw');        # 'record' is another possibility
  $PortObj->cfg_param_1('none');
  $PortObj->cfg_param_2('none');    # 3 spares should be enough for now
  $PortObj->cfg_param_3('none');

Configuration and Capability Methods

The get_tick_count method is a clone of the Win32::GetTickCount() function. It matches a corresponding method in Win32::CommPort. It returns time in milliseconds - but can be used in cross-platform scripts.

Operating Methods

  $PortObj->pulse_break_on($milliseconds);
  $PortObj->pulse_rts_on($milliseconds);
  $PortObj->pulse_rts_off($milliseconds);
  $PortObj->pulse_dtr_on($milliseconds);
  $PortObj->pulse_dtr_off($milliseconds);

In Version 0.05, these calls and the rts_active and dtr_active calls verify the parameters and any required ioctl constants, and return "undef" unless the call succeeds. You can use the can_ioctl method to see if the required constants are available. On Version 0.04, the module would not load unless asm/termios.ph was found at startup.

Stty Shortcuts

The methods which handle CHAR parameters set and return values as "ord(CHAR)". This corresponds to the settings in the POSIX termios cc_field array. You are unlikely to actually want to modify most of these. They reflect the special characters which can be set by stty.

  $PortObj->is_xon_char($num_char);     # VSTART (stty start=.)
  $PortObj->is_xoff_char($num_char);    # VSTOP
  $PortObj->is_stty_intr($num_char);    # VINTR
  $PortObj->is_stty_quit($num_char);    # VQUIT
  $PortObj->is_stty_eof($num_char);     # VEOF
  $PortObj->is_stty_eol($num_char);     # VEOL
  $PortObj->is_stty_erase($num_char);   # VERASE
  $PortObj->is_stty_kill($num_char);    # VKILL
  $PortObj->is_stty_susp($num_char);    # VSUSP

Binary settings supported by POSIX will return 0 or 1. Several parameters settable by stty do not yet have shortcut methods. Contact me if you need one that is not supported. These are the common choices. Try "man stty" if you are not sure what they do.

  $PortObj->stty_echo;
  $PortObj->stty_echoe;
  $PortObj->stty_echok;
  $PortObj->stty_echonl;
  $PortObj->stty_ignbrk;
  $PortObj->stty_istrip;
  $PortObj->stty_inpck;
  $PortObj->stty_parmrk;
  $PortObj->stty_ignpar;
  $PortObj->stty_icrnl;
  $PortObj->stty_igncr;
  $PortObj->stty_inlcr;
  $PortObj->stty_opost;
  $PortObj->stty_isig;
  $PortObj->stty_icanon;

The following methods require successfully loading ioctl constants. They will return "undef" if the needed constants are not found. But the method calls may still be used without syntax errors or warnings even in that case.

  $PortObj->stty_ocrlf;
  $PortObj->stty_onlcr;
  $PortObj->stty_echoke;
  $PortObj->stty_echoctl;

Lookfor and I/O Processing

Unlike Win32::SerialPort, lookfor does not handle backspace, echo, and other character processing. It expects the serial driver to handle those and to be controlled via stty. For interacting with humans, you will probably want stty_icanon(1) during lookfor to obtain familiar command-line response. The actual match and the characters after it (if any) may also be viewed using the lastlook method. It also adopts the convention from Expect.pm that match strings are literal text (tested using index) unless preceeded in the are_match list by a "-re", entry. The default are_match list is "("\n")", which matches complete lines.

   my ($match, $after, $pattern, $instead) = $PortObj->lastlook;
     # input that MATCHED, input AFTER the match, PATTERN that matched
     # input received INSTEAD when timeout without match ("" if match)

   $PortObj->are_match("text1", "-re", "pattern", "text2");
     # possible match strings: "pattern" is a regular expression,
     #                         "text1" and "text2" are literal strings

Everything in lookfor is still experimental. Please let me know if you use it (or can't use it), so I can confirm bug fixes don't break your code. For literal strings, $match and $pattern should be identical. The $instead value returns the internal buffer tested by the match logic. A successful match or a lookclear resets it to "" - so it is only useful for error handling such as timeout processing or reporting unexpected responses.

The lookfor method is designed to be sampled periodically (polled). Any characters after the match pattern are saved for a subsequent lookfor. Internally, lookfor is implemented using the nonblocking input method when called with no parameter. If called with a count, lookfor calls "$PortObj->read(count)" which blocks until the read is Complete or a Timeout occurs. The blocking alternative should not be used unless a fault time has been defined using read_interval, read_const_time, and read_char_time. It exists mostly to support the tied FileHandle functions sysread, getc, and <FH>. When stty_icanon is active, even the non-blocking calls will not return data until the line is complete.

The internal buffers used by lookfor may be purged by the lookclear method (which also clears the last match). For testing, lookclear can accept a string which is "looped back" to the next input. This feature is enabled only when set_test_mode_active(1). Normally, lookclear will return "undef" if given parameters. It still purges the buffers and last_match in that case (but nothing is "looped back"). You will want stty_echo(0) when exercising loopback.

The matchclear method is designed to handle the "special case" where the match string is the first character(s) received by lookfor. In this case, "$lookfor_return == """, lookfor does not provide a clear indication that a match was found. The matchclear returns the same $match that would be returned by lastlook and resets it to "" without resetting any of the other buffers. Since the lookfor already searched through the match, matchclear is used to both detect and step-over "blank" lines.

The character-by-character processing used by lookfor is fine for interactive activities and tasks which expect short responses. But it has too much "overhead" to handle fast data streams.There is also a streamline method which is a fast, line-oriented alternative with just pattern searching. Since streamline uses the same internal buffers, the lookclear, lastlook, are_match, and matchclear methods act the same in both cases. In fact, calls to streamline and lookfor can be interleaved if desired (e.g. an interactive task that starts an upload and returns to interactive activity when it is complete).

There are two additional methods for supporting "list context" input: lastline sets an "end_of_file" Regular Expression, and linesize permits changing the "packet size" in the blocking read operation to allow tuning performance to data characteristics. These two only apply during READLINE. The default for linesize is 1. There is no default for the lastline method.

The Regular Expressions set by are_match and lastline will be pre-compiled using the qr// construct on Perl 5.005 and higher. This doubled lookfor and streamline speed in my tests with Regular Expressions - but actual improvements depend on both patterns and input data.

The functionality of lookfor includes a limited subset of the capabilities found in Austin Schutz's Expect.pm for Unix (and Tcl's expect which it resembles). The "$before, $match, $pattern, and $after" return values are available if someone needs to create an "expect" subroutine for porting a script. When using multiple patterns, there is one important functional difference: Expect.pm looks at each pattern in turn and returns the first match found; lookfor and streamline test all patterns and return the one found earliest in the input if more than one matches.

Exports

:PARAM

Utility subroutines and constants for parameter setting and test:

        LONGsize        SHORTsize       nocarp          yes_true
        OS_Error
    

:STAT

The Constants named BM_* and CE_* are omitted. But the modem status (MS_*) Constants are defined for possible use with modemlines and wait_modemlines. They are assigned to corresponding functions, but the bit position will be different from that on Win32.

Which incoming bits are active:

        MS_CTS_ON    - Clear to send
    MS_DSR_ON    - Data set ready
    MS_RING_ON   - Ring indicator  
    MS_RLSD_ON   - Carrier detected
    MS_RTS_ON    - Request to send (might not exist on Win32)
    MS_DTR_ON    - Data terminal ready (might not exist on Win32)
    

If you want to write more POSIX-looking code, you can use the constants seen there, instead of the Win32 versions:

    TIOCM_CTS, TIOCM_DSR, TIOCM_RI, TIOCM_CD, TIOCM_RTS, and TIOCM_DTR
    

Offsets into the array returned by status:

        ST_BLOCK        ST_INPUT        ST_OUTPUT       ST_ERROR
    

:ALL

All of the above. Except for the test suite, there is not really a good reason to do this.

Win32::SerialPort Functions Not Currently Supported

  $LatchErrorFlags = $PortObj->reset_error;

  $PortObj->read_interval(100);         # max time between read char
  $PortObj->write_char_time(5);
  $PortObj->write_const_time(100);

Functions Handled in a POSIX system by "stty"

        xon_limit       xoff_limit      xon_char        xoff_char
        eof_char        event_char      error_char      stty_intr
        stty_quit       stty_eof        stty_eol        stty_erase
        stty_kill       stty_clear      is_stty_clear   stty_bsdel      
        stty_echoke     stty_echoctl    stty_ocrnl      stty_onlcr

Win32::SerialPort Functions Not Ported to POSIX

        transmit_char

Win32API::CommPort Functions Not Ported to POSIX

        init_done       fetch_DCB       update_DCB      initialize
        are_buffers     are_baudrate    are_handshake   are_parity
        are_databits    are_stopbits    is_handshake    xmit_imm_char
        is_baudrate     is_parity       is_databits     is_write_char_time
        debug_comm      is_xon_limit    is_xoff_limit   is_read_const_time
        suspend_tx      is_eof_char     is_event_char   is_read_char_time
        is_read_buf     is_write_buf    is_buffers      is_read_interval
        is_error_char   resume_tx       is_stopbits     is_write_const_time
        is_binary       is_status       write_bg        is_parity_enable
        is_modemlines   read_bg         read_done       break_active
        xoff_active     is_read_buf     is_write_buf    xon_active

"raw" Win32 API Calls and Constants

:RAW

The API Wrapper Methods and Constants used only to support them including PURGE_*, SET*, CLR*, EV_*, and ERROR_IO*

:COMMPROP

The Constants used for Feature and Properties Detection including BAUD_*, PST_*, PCF_*, SP_*, DATABITS_*, STOPBITS_*, PARITY_*, and COMMPROP_INITIALIZED

:DCB

The constants for the Win32 Device Control Block including CBR_*, DTR_*, RTS_*, *PARITY, *STOPBIT*, and FM_*

Compatibility