Device::SerialPort - Linux/POSIX emulation of Win32::SerialPort functions.
use Device::SerialPort qw( :PARAM :STAT 0.09 );
# $quiet and $lockfile are 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";
$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
# 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 by eval
($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
$ModemStatus = $PortObj->modemlines;
if ($ModemStatus & $PortObj->MS_RLSD_ON) { print "carrier detected"; }
($BlockingFlags, $InBytes, $OutBytes, $ErrorFlags) = $PortObj->status;
# same format for compatibility. Only $InBytes and $OutBytes are
# currently returned (on linux). Others are 0.
($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
$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;
$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");
$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;
$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
This module provides an object-based user interface essentially identical to the one provided by the Win32::SerialPort module.
The primary constructor is new with a PortName, or a
Configuration File specified. With a PortName, this
will open the port and create the object. 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 updates the port (and will return True under POSIX). Ports are
opened for binary transfers. A separate binmode is not needed.
$PortObj = new Device::SerialPort ($PortName, $quiet, $lockfile)
|| die "Can't open $PortName: $!\n";
There are two optional parameters for new. Failure to open a port prints an error message to STDOUT by default.
Since other applications can use the port, one source of failure is ``port
in use''. There was originally no way to check this without getting a
``fail message''. Setting $quiet disables this built-in message. It also returns 0 instead of undef if the port is unavailable (still FALSE, used for testing this condition -
other faults may still return undef). Use of $quiet only applies to new.
The $lockfile parameter has a related purpose. 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.09. 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
the 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).
Certain parameters SHOULD be set before executing write_settings. Others will attempt to deduce defaults from the hardware or from other parameters. The Required parameters are:
Any legal value.
One of the following: ``none'', ``odd'', ``even''. If you select anything except ``none'', you will need to set parity_enable.
An integer from 5 to 8.
Legal values are 1 and 2.
One of the following: ``none'', ``rts'', ``xoff''.
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
Use alias to convert the name used by ``built-in'' messages.
$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');
The Win32 Serial Comm API provides extensive information concerning the capabilities and options available for a specific port (and instance). This module will return suitable responses to facilitate porting code from that environment.
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.
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 two different ways:
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 $user_msg is true. The port will be updated immediately if allowed (an automatic write_settings is called).
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.
Methods which only accept a limited number of specific input values return
a list consisting of all acceptable choices. The null list
(undef) will be returned for failed calls in list context (e.g. for an invalid or
unexpected argument). Only the baudrate, parity, databits, stopbits, and
handshake methods currently support this feature.
Version 0.04 adds pulse methods for the RTS, BREAK, and DTR bits. The pulse methods assume the bit is in the opposite state when the method is called. They set the requested state, delay the specified number of milliseconds, set the opposite state, and again delay the specified time. These methods are designed to support devices, such as the X10 ``FireCracker'' control and some modems, which require pulses on these lines to signal specific events or data. Timing for the active part of pulse_break_on is handled by POSIX::tcsendbreak(0), which sends a 250-500 millisecond BREAK pulse. It is NOT guaranteed to block until done.
$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.
Version 0.06 adds primitive methods to modify port parameters that would
otherwise require a system("stty..."); command. These act much like the identically-named methods in
Win32::SerialPort. However, they are initialized from ``current stty
settings'' when the port is opened rather than from defaults. And like stty settings, they are passed to the serial driver and apply to all operations rather
than only to I/O processed via the lookfor method or the tied FileHandle methods. Each returns the current setting for the parameter. There are no
``global'' or ``combination'' parameters - you still need system("stty...") for that.
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_istrip; $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;
Some communications programs have a different 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 up to 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).
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.
Nothing is exported by default. The following tags can be used to have large sets of symbols exported:
Utility subroutines and constants for parameter setting and test:
LONGsize SHORTsize nocarp yes_true
OS_Error
The Constants named BM_* and CE_* are omitted. But the MS_* Constants are defined for possible use with 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 MS_DSR_ON MS_RING_ON MS_RLSD_ON
Offsets into the array returned by status:
ST_BLOCK ST_INPUT ST_OUTPUT ST_ERROR
All of the above. Except for the test suite, there is not really a good reason to do this.
The object returned by new 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";
This module uses POSIX termios extensively. Raw API calls are very unforgiving. You will certainly want to start perl with the -w switch. If you can, use strict as well. Try to ferret out all the syntax and usage problems BEFORE issuing the API calls (many of which modify tuning constants in hardware device drivers....not where you want to look for bugs).
With all the options, this module needs a good tutorial. It doesn't have one yet.
The current version of the module has been tested with Perl 5.003 and above. It was initially ported from Win32 and was designed to be used without requiring a compiler or using XS. 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.
The read method, and tied methods which call it, currently can use a fixed timeout which approximates behavior of the Win32::SerialPort read_const_time and read_char_time methods. It is used internally by select. If the timeout is set to zero, the read call will return immediately. A read larger than 255 bytes will be split internally into 255-byte POSIX calls due to limitations of select and VMIN. The timeout is reset for each 255-byte segment. Hence, for large reads, use a read_const_time suitable for a 255-byte read. All of this is expeimental in Version 0.055.
$PortObj->read_const_time(500); # 500 milliseconds = 0.5 seconds $PortObj->read_char_time(5); # avg time between read char
The timing 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.
Read_Total = read_const_time + (read_char_time * bytes_to_read)
Write timeouts and read_interval timeouts are not currently supported.
See the limitations about lockfiles. Experiment if you like.
The location of termios.ph is different on other Operating Systems. Some may not have it at all or may
use a different name. Please report locations you find which differ from
this so I can add them to later versions.
With all the currently unimplemented features, we don't need any more. But there probably are some.
__Please send comments and bug reports to wcbirthisel@alum.mit.edu.
$LatchErrorFlags = $PortObj->reset_error;
$PortObj->read_interval(100); # max time between read char $PortObj->write_char_time(5); $PortObj->write_const_time(100);
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
transmit_char
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
A large number of Win32-specific elements have been omitted. Most of these are only available in Win32::SerialPort and Win32API::CommPort as optional Exports. The list includes the following:
The API Wrapper Methods and Constants used only to support them including PURGE_*, SET*, CLR*, EV_*, and ERROR_IO*
The Constants used for Feature and Properties Detection including BAUD_*, PST_*, PCF_*, SP_*, DATABITS_*, STOPBITS_*, PARITY_*, and COMMPROP_INITIALIZED
The constants for the Win32 Device Control Block including CBR_*, DTR_*, RTS_*, *PARITY, *STOPBIT*, and FM_*
This code implements the functions required to support the MisterHouse Home Automation software by Bruce Winter. It does not attempt to support functions from Win32::SerialPort such as stty_emulation that already have POSIX implementations or to replicate Win32 idosyncracies. However, the supported functions are intended to clone the equivalent functions in Win32::SerialPort and Win32API::CommPort. Any discrepancies or omissions should be considered bugs and reported to the maintainer.
Based on Win32::SerialPort.pm, Version 0.8, by Bill Birthisel, http://members.aol.com/Bbirthisel/.
Ported to linux/POSIX by Joe Doss for MisterHouse
Ported to Solaris, AIX, OpenBSD by Kees Cook for Sendpage
Currently maintained by: Kees Cook, cook-cpan@outflux.net, http://outflux.net/
Win32API::CommPort
Win32::SerialPort
Perltoot.xxx - Tom (Christiansen)'s Object-Oriented Tutorial
Copyright (C) 1999, Bill Birthisel. All rights reserved.
Copyright (C) 2001, Kees Cook. All rights reserved.
This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself. 27 Jan 2001