• NAME
• SYNOPSIS
  • Constructors
  • Configuration Utility Methods
  • Configuration Parameter Methods
  • Operating Methods
  • Capability Methods inherited from Win32API::CommPort
  • Operating Methods inherited from Win32API::CommPort
  • Methods not yet Implemented
• DESCRIPTION
  • Initialization
  • Configuration and Capability Methods
  • Exports
  • Stty Emulation
• NOTES
• KNOWN LIMITATIONS
• BUGS
• AUTHORS
• SEE ALSO
• COPYRIGHT
  • DISCLAIMER

NAME

SYNOPSIS

  use Win32;
  require 5.003;
  use Win32::SerialPort qw( :STAT 0.10 );

Constructors

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

  $PortObj = start Win32::SerialPort ($Configuration_File_Name)
       || die "Can't start $Configuration_File_Name: $^E\n";

Configuration Utility Methods

  $PortObj->alias("MODEM1");

     # before using start
  $PortObj->save($Configuration_File_Name)
       || warn "Can't save $Configuration_File_Name: $^E\n";

     # after new, must check for failure
  $PortObj->write_settings || undef $PortObj;
  print "Can't change Device_Control_Block: $^E\n" unless ($PortObj);

     # 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: $^E\n";

Configuration Parameter Methods

     # most methods can be called three ways:
  $PortObj->handshake("xoff");           # set parameter
  $flowcontrol = $PortObj->handshake;    # current value (scalar)
  @handshake_opts = $PortObj->handshake; # permitted choices (list)

     # similar
  $PortObj->baudrate(9600);
  $PortObj->parity("odd");
  $PortObj->databits(8);
  $PortObj->stopbits(1.5);
  $PortObj->debug(0);

     # range parameters return (minimum, maximum) in list context
  $PortObj->xon_limit(100);      # bytes left in buffer
  $PortObj->xoff_limit(100);     # space left in buffer
  $PortObj->xon_char(0x11);
  $PortObj->xoff_char(0x13);
  $PortObj->eof_char(0x0);
  $PortObj->event_char(0x0);
  $PortObj->error_char(0);       # for parity errors

  $PortObj->buffers(4096, 4096);  # read, write
        # returns current in list context

  $PortObj->read_interval(100);    # max time between read char (milliseconds)
  $PortObj->read_char_time(5);     # avg time between read char
  $PortObj->read_const_time(100);  # total = (avg * bytes) + const 
  $PortObj->write_char_time(5);
  $PortObj->write_const_time(100);

     # true/false parameters (return scalar context only)

  $PortObj->binary(T);          # just say Yes (Win 3.x option)

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

     # test suite only
  @necessary_param = SerialPort->set_test_mode_active;

Operating Methods

  ($BlockingFlags, $InBytes, $OutBytes, $LatchErrorFlags) = $PortObj->status
        || warn "could not get port status\n";

  if ($BlockingFlags) { warn "Port is blocked"; }
  if ($BlockingFlags & BM_fCtsHold) { warn "Waiting for CTS"; }
  if ($LatchErrorFlags & CE_FRAME) { warn "Framing Error"; }
        # The API resets errors when reading status, $LatchErrorFlags
        # is all $ErrorFlags seen since the last reset_error

Additional useful constants may be exported eventually. If the only fault action desired is a message, status provides Built-In BitMask processing:

  $PortObj->error_msg(1);  # prints major messages like "Framing Error"
  $PortObj->user_msg(1);   # prints minor messages like "Waiting for CTS"

  ($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

  $PortObj->transmit_char(0x03);        # bypass buffer (and suspend)

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

  $PortObj->close;      ## passed to CommPort; undef $PortObj preferred

Capability Methods inherited from Win32API::CommPort

  can_baud            can_databits           can_stopbits
  can_dtrdsr          can_handshake          can_parity_check 
  can_parity_config   can_parity_enable      can_rlsd 
  can_16bitmode       is_rs232               is_modem 
  can_rtscts          can_xonxoff            can_xon_char 
  can_spec_char       can_interval_timeout   can_total_timeout 
  buffer_max          can_rlsd_config

Operating Methods inherited from Win32API::CommPort

  write_bg            write_done             read_bg
  read_done           reset_error            suspend_tx
  resume_tx           dtr_active             rts_active
  break_active        xoff_active            xon_active
  purge_all           purge_rx               purge_tx

Methods not yet Implemented

  $PortObj = dosmode Win32::SerialPort ($MS_Dos_Mode_String)
       || die "Can't complete dosmode open: $^E\n";

  ($complete, $count_in, $string_in) = $PortObj->readline($prompt);
  $PortObj->readline_end("\012");
  $PortObj->echo(OFF);  # input from a terminal (readline)
     # a number of others to provide "stty-like" settings

  $PortObj->ignore_null(No);
  $PortObj->ignore_no_dsr(No);
  $PortObj->abort_on_error("no");
  $PortObj->subst_pe_char("no");

  $PortObj->accept_xoff(F);     # hold during output
  $PortObj->accept_dsr(F);
  $PortObj->accept_cts(F);
  $PortObj->send_xoff(N);
  $PortObj->tx_on_xoff(Y);

DESCRIPTION

Uses features of the Win32 API to implement non-blocking I/O, serial parameter setting, event-loop operation, and enhanced error handling.

To pass in NULL as the pointer to an optional buffer, pass in $null=0. This is expected to change to an empty list reference, [], when perl supports that form in this usage.

Initialization

Certain parameters MUST be set before executing write_settings. Others will attempt to deduce defaults from the hardware or from other parameters. The Required parameters are:

baudrate

Any legal value.

parity

One of the following: ``none'', ``odd'', ``even'', ``mark'', ``space''. If you select anything except ``none'', you will need to set parity_enable.

databits

An integer from 5 to 8.

stopbits

Legal values are 1, 1.5, and 2.

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

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

  $PortObj->user_msg(ON);
  $PortObj->databits(8);
  $PortObj->baudrate(9600);
  $PortObj->parity("none");
  $PortObj->stopbits(1.5);
  $PortObj->handshake("rts");
  $PortObj->buffers(4096, 4096);

  $PortObj->write_settings || undef $PortObj;

  $PortObj->save($Configuration_File_Name);

  $PortObj->baudrate(300);

  undef $PortObj;  # closes port AND frees memory in perl

The PortName maps to both the Registry Device Name and the Properties associated with that device. A single Physical port can be accessed using two or more Device Names. But the options and setup data will differ significantly in the two cases. A typical example is a Modem on port ``COM2''. Both of these PortNames open the same Physical hardware:

  $P1 = new Win32::SerialPort ("COM2");

  $P2 = new Win32::SerialPort ("\\\\.\\Nanohertz Modem model K-9");

$P1 is a ``generic'' serial port. $P2 includes all of $P1 plus a variety of modem-specific added options and features. The ``raw'' API calls return different size configuration structures in the two cases. Win32 uses the ``\\.\'' prefix to identify ``named'' devices. Since both names use the same Physical hardware, they can not both be used at the same time. The OS will complain. Consider this A Good Thing. Use alias to convert the name used by ``built-in'' messages.

  $P2->alias("FIDO");

The second constructor, start is intended to simplify scripts which 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.

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

A possible third constructor, dosmode, is a further simplification. The parameters are specified as in the MS-DOS 6.x "MODE" command. Unspecified parameters would be set to plausible ``DOS like'' defaults. Once created, all of the parameter settings would be available.

  $PortObj3 = dosmode Win32::SerialPort ($MS_Dos_Mode_String)
       || die "Can't complete dosmode open: $^E\n";

Configuration and Capability Methods

Binary selections will accept as true any of the following: ("YES", "Y", "ON", "TRUE", "T", "1", 1) (upper/lower/mixed case) Anything else is false.

There are a large number of possible configuration and option parameters. To facilitate checking option validity in scripts, most configuration methods can be used in three different ways:

method called with an argument

The parameter is set to the argument, if valid. An invalid argument returns false (undef) and the parameter is unchanged. The function will also carp if $error_msg is true. After write_settings, the port will be updated immediately if allowed. Otherwise, the value will be applied when write_settings is called.

method called with no argument in scalar context

The current value is returned. If the value is not initialized either directly or by default, return ``undef'' which will parse to false. For binary selections (true/false), return the current value. All current values from ``multivalue'' selections will parse to true. Current values may differ from requested values until write_settings. There is no way to see requests which have not yet been applied. Setting the same parameter again overwrites the first request. Test the return value of the setting method to check ``success''.

method called with no argument in list context

Return a list consisting of all acceptable choices for parameters with discrete choices. Return a list (minimum, maximum) for parameters which can be set to a range of values. Binary selections have no need to call this way - but will get (0,1) if they do. The null list (undef) will be returned for failed calls in list context (e.g. for an invalid or unexpected argument).

Exports

:PARAM

Utility subroutines and constants for parameter setting and test:

        LONGsize        SHORTsize       nocarp          Yes_true
        OS_Error

:STAT

Serial communications constants from Win32API::CommPort. Included are the constants for ascertaining why a transmission is blocked:

        BM_fCtsHold     BM_fDsrHold     BM_fRlsdHold    BM_fXoffHold
        BM_fXoffSent    BM_fEof         BM_fTxim        BM_AllBits

Which incoming bits are active:

        MS_CTS_ON       MS_DSR_ON       MS_RING_ON      MS_RLSD_ON

What hardware errors have been detected:

        CE_RXOVER       CE_OVERRUN      CE_RXPARITY     CE_FRAME
        CE_BREAK        CE_TXFULL       CE_MODE

Offsets into the array returned by status:

        ST_BLOCK        ST_INPUT        ST_OUTPUT       ST_ERROR

Stty Emulation

Until that time, the following table shows correspondance between stty and SerialPort functions:

        The following stty functions have equivalents in SerialPort:
        ------------------------------------------------------------
        stty functions                  related SerialPort functions
        --------------------            ----------------------------
        parenb -parenb                  parity_enable
        
        parodd -parodd                  parity
        
        cs5 cs6 cs7 cs8                 databits
        
        cstopb -cstopb                  stopbits
        
        clocal -clocal ixon -ixon       handshake
        
        ixoff -ixoff                    xon_limit, xoff_limit
        
        parmrk -parmrk                  error_char
        
        sane                            restart
        
        start                           xon_char
        
        stop                            xoff_char
        
        time                            read_const_time
        
        110 300 600 1200 2400           baudrate
        4800 9600 19200 38400           baudrate
        
        75 134.5 150 1800               fixed baud only - not selectable
        
        -g, "stty < /dev/x"             start, save
        
        raw                             read, write
        
        -icanon                         input
        
        
        The following stty functions will have equivalents in SerialPort
        after readline (canonical processing) is implemented:
        ----------------------------------------------------------------
        stty functions                  related SerialPort functions
        --------------------            ----------------------------
        intr                            intr_char
        
        eof                             eof_char
        
        eol                             readline_end
        
        cooked icanon                   readline
        
        noflsh -noflsh                  purge_all, purge_rx, purge_tx
        
        
        Equivalents for the following stty functions are expected but
        have not yet been defined in SerialPort:
        -------------------------------------------------------------
        [-]istrip       [-]inlcr        [-]igncr        [-]icrnl
        [-]isig         [-]echo         [-]echoe        [-]crterase
        [-]echok        [-]echonl       ek              [-]pass8
        dec             erase           kill            min
        
        
        The following stty functions have no equivalent in SerialPort:
        --------------------------------------------------------------
        -a              -v              [-]cread        [-]hupcl
        [-]hup          [-]ignbrk       [-]brkint       [-]ignpar
        [-]inpck        [-]opost        [-]tostop       susp
        quit            0               50              134
        200             exta            extb

The stty function list is taken from the documentation for IO::Stty by Austin Schutz.

NOTES

e.g. the following is WRONG!!____print $PortObj "some text";

An important note about Win32 filenames. The reserved device names such as

 COM1, AUX, LPT1, CON, PRN 

Thanks to Ken White for testing on NT.

KNOWN LIMITATIONS

Tutorial

With all the options, this module needs a good tutorial. It doesn't have one yet. The demo programs are a good starting point.

Buffers

The size of the Win32 buffers are selectable with buffers. But each read method currently uses a fixed internal buffer of 4096 bytes. There are other fixed internal buffers as well. The XS version will support dynamic buffer sizing.

Modems

Lots of modem-specific options are not supported. The same is true of TAPI, MAPI. Of course, API Wizards are welcome to contribute.

API Options

Lots of options are just ``passed through from the API''. Some probably shouldn't be used together. The module validates the obvious choices when possible. For something really fancy, you may need additional API documentation. Available from Micro$oft Pre$$.

Asynchronous (Background) I/O

This version now handles Polling (do if Ready), Synchronous (block until Ready), and Asynchronous Modes (begin and test if Ready) with the timeout choices provided by the API. No effort has yet been made to interact with TK events (or Windows events).

Timeouts

The API provides two timing models. The first applies only to read and essentially determines Read Not Ready by checking the time between consecutive characters. The ReadFile operation returns if that time exceeds the value set by read_interval. It does this by timestamping each character. It appears that at least one character must by received to initialize the mechanism.

The other model defines the total time allowed to complete the operation. A fixed overhead time is added to the product of bytes and per_byte_time. A wide variety of timeout options can be defined by selecting the three parameters: fixed, each, and size.

Read_total = read_const_time + (read_char_time * bytes_to_read)

Write_total = write_const_time + (write_char_time * bytes_to_write)

BUGS

On NT, a read_done or write_done returns False if a background operation is aborted by a purge. Win95 returns True.

EXTENDED_OS_ERROR ($^E) is not supported by the binary ports before 5.005. It ``sort-of-tracks'' $! in 5.003 and 5.004, but YMMV.

__Please send comments and bug reports to wcbirthisel@alum.mit.edu.

AUTHORS

Tye McQueen, tye@metronet.com, http://www.metronet.com/~tye/.

SEE ALSO

Win32API::File when available

Win32::API - Aldo Calpini's ``Magic'', http://www.divinf.it/dada/perl/

Perltoot.xxx - Tom (Christiansen)'s Object-Oriented Tutorial

COPYRIGHT

This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

DISCLAIMER