NAME

Win32::SerialPort - User interface to Win32 Serial API calls

SYNOPSIS

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

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

     # specials for test suite only
  @necessary_param = Win32::SerialPort->set_test_mode_active(1);
  $PortObj->lookclear("loopback to next 'input' method");

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

Methods for I/O Processing

$PortObj->are_match("pattern", "\n");	# possible end strings
$PortObj->lookclear;			# empty buffers
$PortObj->write("Feed Me:");		# initial prompt
$PortObj->is_prompt("More Food:");	# new prompt after "kill" char

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) = $PortObj->lastlook;	# match and input after
printf "lastlook-match = %s  -after = %s\n", $match, $after;

$PortObj->stty_intr("\cC");	# char to abort lookfor method
$PortObj->stty_quit("\cD");	# char to abort perl
$PortObj->stty_eof("\cZ");	# end_of_file char
$PortObj->stty_eol("\cJ");	# end_of_line char
$PortObj->stty_erase("\cH");	# delete one character from buffer (backspace)
$PortObj->stty_kill("\cU");	# clear line buffer

$PortObj->is_stty_intr(3);	# ord(char) to abort lookfor method
$qc = $PortObj->is_stty_quit;	# ($qc == 4) for "\cD"
$PortObj->is_stty_eof(26);
$PortObj->is_stty_eol(10);
$PortObj->is_stty_erase(8);
$PortObj->is_stty_kill(21);

my $air = " "x76;
$PortObj->stty_clear("\r$air\r");	# written after kill character
$PortObj->is_stty_clear;		# internal version for config file
$PortObj->stty_bsdel("\cH \cH");	# written after erase character

$PortObj->stty_echo(1);	# echo every character
$PortObj->stty_echoe(1);	# echo erase character with bsdel string
$PortObj->stty_echok(1);	# echo \n after kill character
$PortObj->stty_echonl(0);	# echo \n 
$PortObj->stty_echoke(1);	# echo clear string after kill character
$PortObj->stty_echoctl(0);	# echo "^Char" for control chars
$PortObj->stty_istrip(0);	# strip input to 7-bits
$PortObj->stty_icrnl(1);	# map \r to \n on input
$PortObj->stty_ocrnl(0);	# map \r to \n on output
$PortObj->stty_igncr(0);	# ignore \r on input
$PortObj->stty_inlcr(0);	# map \n to \r on input
$PortObj->stty_onlcr(1);	# map \n to \r\n on output
$PortObj->stty_isig(0);	# enable quit and intr characters
$PortObj->stty_icanon(1);	# enable erase and kill characters

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

# no demand for this one yet - may never exist
$PortObj = dosmode Win32::SerialPort ($MS_Dos_Mode_String)
     || die "Can't complete dosmode open: $^E\n";

$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

This module uses Win32API::CommPort for raw access to the API calls and related constants. It provides an object-based user interface to allow higher-level use of common API call sequences for dealing with serial ports.

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

The primary constructor is new with a PortName (as the Registry knows it) specified. This will create an object, and get the available options and capabilities via the Win32 API. The object is a superset of a Win32API::CommPort object, and supports all of its methods. The port is not yet ready for read/write access. First, the desired parameter settings must be established. Since these are tuning constants for an underlying hardware driver in the Operating System, they are all checked for validity by the methods that set them. The write_settings method writes a new Device Control Block to the driver. The write_settings method will return true if the port is ready for access or undef on failure. Ports are opened for binary transfers. A separate binmode is not needed. The USER must release the object if write_settings does not succeed.

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.

The handshake setting is recommended but no longer required. Select one of the following: "none", "rts", "xoff", "dtr".

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

The Win32 Serial Comm API provides extensive information concerning the capabilities and options available for a specific port (and instance). "Modem" ports have different capabilties than "RS-232" ports - even if they share the same Hardware. Many traditional modem actions are handled via TAPI. "Fax" ports have another set of options - and are accessed via MAPI. Yet many of the same low-level API commands and data structures are "common" to each type ("Modem" is implemented as an "RS-232" superset). In addition, Win95 supports a variety of legacy hardware (e.g fixed 134.5 baud) while WinNT has hooks for ISDN, 16-data-bit paths, and 256Kbaud.

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

Nothing is exported by default. Nothing is currently exported. Optional tags from Win32API::CommPort are passed through.

: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

Nothing wrong with dreaming! At some point in the future, a subset of stty options will be available through a stty method. The purpose would be support of existing serial devices which have embedded knowledge of Unix communication line and login practices.

Version 0.13 adds the primative functions required to implement this feature. There is not a unified stty method yet. But a number of methods named stty_xxx do what an experienced stty user would expect. Unlike stty on Unix, the stty_xxx operations apply only to I/O processed via the lookfor method. The read, input, read_done, write methods all treat data as "raw".

        The following stty functions have related SerialPort functions:
        ---------------------------------------------------------------
        stty (control)		SerialPort		Default Value
        ----------------	------------------      -------------
        parenb inpck		parity_enable		from port
        
        parodd			parity			from port
        
        cs5 cs6 cs7 cs8		databits		from port
        
        cstopb			stopbits		from port
        
        clocal ixon crtscts	handshake		from port
        
        ixoff			xon_limit, xoff_limit	from port

        time			read_const_time		from port
        
        110 300 600 1200 2400	baudrate		from port
        4800 9600 19200 38400	baudrate
        
        75 134.5 150 1800	fixed baud only - not selectable
        
        g, "stty < /dev/x"	start, save		none
        
        sane			restart			none

       
 
        stty (input)		SerialPort		Default Value
        ----------------	------------------      -------------
	istrip			stty_istrip		off
        
	igncr			stty_igncr		off
        
	inlcr			stty_inlcr		off
        
	icrnl			stty_icrnl		on
        
        parmrk			error_char		from port (off typ)

       
 
        stty (output)		SerialPort		Default Value
        ----------------	------------------      -------------
	ocrnl			stty_ocrnl		off
        
	onlcr			stty_onlcr		on

       
 
        stty (local)		SerialPort		Default Value
        ----------------	------------------      -------------
        raw			read, write, input	none
        
        cooked			lookfor			none
        
	echo			stty_echo		on
        
	echoe			stty_echoe		on
        
	echok			stty_echok		on
        
	echonl			stty_echonl		off
        
	echoke			stty_echoke		on
        
	echoctl			stty_echoctl		off

	isig			stty_isig		off

	icanon			stty_icanon		on
      
 
 
        stty (char)		SerialPort		Default Value
        ----------------	------------------      -------------
	intr			stty_intr		"\cC"
				is_stty_intr		3

	quit			stty_quit		"\cD"
				is_stty_quit		4

	erase			stty_erase		"\cH"
				is_stty_erase		8

	(erase echo)		stty_bsdel		"\cH \cH"

	kill			stty_kill		"\cU"
				is_stty_kill		21

	(kill echo)		stty_clear		"\r {76}\r"
				is_stty_clear		"-@{76}-"

	eof			stty_eof		"\cZ"
				is_stty_eof		26

	eol			stty_eol		"\cJ"
				is_stty_eol		10

        start			xon_char		from port ("\cQ" typ)
        
        stop			xoff_char		from port ("\cS" typ)
        
        
        
        The following stty functions have no equivalent in SerialPort:
        --------------------------------------------------------------
        -a		-v		[-]cread	[-]hupcl
        [-]hup		[-]ignbrk	[-]brkint	[-]ignpar
        [-]opost	[-]tostop	susp		0
	50		134		200		exta
	extb

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

Lookfor and I/O Processing

Many of the stty_xxx methods support features which are necessary for line-oriented input (such as command-line handling). These include methods which select control-keys to delete characters (stty_erase) and lines (stty_kill), define input boundaries (stty_eol, stty_eof), and abort processing (stty_intr, stty_quit). These keys also have is_stty_xxx methods which convert the key-codes to numeric equivalents which can be saved in the configuration file.

Some communications programs have a different but related need - to collect (or discard) input until a specific pattern is detected. For lines, the pattern is a line-termination. But there are also requirements to search for other strings in the input such as "username:" and "password:". The lookfor method provides a consistant mechanism for solving this problem. It searches input character-by-character looking for a match to any of the elements of an array set using the are_match method. It returns the entire input before the match pattern if a match is found. If no match is found, it returns "" unless an input error or abort is detected (which returns undef). The lookfor method is designed to be sampled periodically (polled). Any characters after the match pattern are saved for a subsequent lookfor. The actual match and the characters after it (if any) may also be viewed using the lastlook method. The default are_match list is ("\n") which matches complete lines.

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 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, $after return values are available if someone needs to create an "expect" subroutine for porting a script.

Because lookfor can be used to manage a command-line environment much like a Unix serial login, a number of "stty-like" methods are included to handle the issues raised by serial logins. One issue is dissimilar line terminations. This is addressed by the following methods:

$PortObj->stty_icrnl;		# map \r to \n on input (default)
$PortObj->stty_igncr;		# ignore \r on input
$PortObj->stty_inlcr;		# map \n to \r on input
$PortObj->stty_ocrnl;		# map \r to \n on output
$PortObj->stty_onlcr;		# map \n to \r\n on output (default)

The default specifies a device which sends "\r" at the end of a line and requires "\r\n" to terminate incoming lines. Many "dumb terminals" act this way.

Sometimes, you want perl to echo input characters back to the serial device (and other times you don't want that).

$PortObj->stty_echo;		# echo every character (default)
$PortObj->stty_echoe;		# echo erase with bsdel string (default)
$PortObj->stty_echok;		# echo \n after kill character (default)
$PortObj->stty_echonl;	# echo \n 
$PortObj->stty_echoke;	# echo clear string after kill (default)
$PortObj->stty_echoctl;	# echo "^Char" for control chars

$PortObj->stty_istrip;	# strip input to 7-bits

my $air = " "x76;		# overwrite entire line with spaces
$PortObj->stty_clear("\r$air\r");	# written after kill character
$PortObj->is_prompt("PROMPT:");	# need to write after kill
$PortObj->stty_bsdel("\cH \cH");	# written after erase character

# internal method that permits clear string with \r in config file
my $plus32 = "@"x76;		# overwrite line with spaces (ord += 32)
$PortObj->is_stty_clear("-$plus32-");	# equivalent to stty_clear

NOTES

The object returned by new or start is NOT a Filehandle. You will be disappointed if you try to use it as one.

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 can NOT be used as filenames. Hence "COM2.cfg" would not be usable for $Configuration_File_Name.

Thanks to Ken White for testing on NT.

KNOWN LIMITATIONS

Since everything is (sometimes convoluted but still pure) perl, you can fix flaws and change limits if required. But please file a bug report if you do. This module has been tested with each of the binary perl versions for which Win32::API is supported: AS builds 315, 316, and 500 and GS 5.004_02. It has only been tested on Intel hardware.

The lookfor and stty_xxx mechanisms should be considered experimental. The have only been tested on a small subset of possible applications. While "\r" characters may be included in the clear string using is_stty_clear internally, "\n" characters may NOT be included in multi-character strings if you plan to save the strings in a configuration file (which uses "\n" as an internal terminator).

There have been several changes to the configuration file. You should rewrite any existing files.

Tutorial

With all the options, this module needs a good tutorial. It doesn't have a complete one yet. A "How to get started" tutorial will appear in The Perl Journal #12 (December 1998). The demo programs are a good starting point for additional examples.

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 Win32, a port which has been closed cannot be reopened again by the same process. If a physical port can be accessed using more than one name (see above), all names are treated as one. Exiting and rerunning the script is ok. The perl script can also be run multiple times within a single batch file or shell script. The Makefile.PL spawns subshells with backticks to run the test suite on Perl 5.003 - ugly, but it works.

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

Bill Birthisel, wcbirthisel@alum.mit.edu, http://members.aol.com/Bbirthisel/.

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

SEE ALSO

Win32API::Comm - the low-level API calls which support this module

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

Copyright (C) 1998, Bill Birthisel. All rights reserved.

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

COMPATIBILITY

This is still Beta code and may be subject to functional changes which are not fully backwards compatible. Version 0.12 added an Install.PL script to put modules into the documented Namespaces. The script uses MakeMaker tools not available in ActiveState 3xx builds. Users of those builds will need to install differently (see README). Some of the optional exports (those under the "RAW:" tag) have been renamed in this version. I do not know of any scripts outside the test suite which will be affected. All of the programs in the test suite have been modified for Version 0.13. They will not work with previous versions. Since the set_test_mode_active function has been designated "test suite only", the change should not effect user scripts. 28 Nov 1998.

cpanm Win32::SerialPort

perl -MCPAN -e shell
install Win32::SerialPort