-----Ruby/SerialPort-----

-- Description --

Ruby/SerialPort is a Ruby library that provides a class for using
RS-232 serial ports.  This class also contains low-level functions to
check and set the current state of the signals on the line.

The native Windows version of this library supports Microsoft's Visual C++,
Borland's C++, and MinGW compilers.

-- Installation --

This gem is hosted at Gemcutter. Before you can install this, or any other
Gemcutter gem you must add it as a gem source:
  gem sources -a http://gemcutter.org

Then you can install the gem as normal:
  sudo gem install serialport

-- Testing --

* test/miniterm.rb

Ruby's copy of miniterm.c !

* test/test_serialport.rb

Unit tests for all functions


-- API --

  **** Class SerialPort, Parent IO ****

    ** Class constants **

       VERSION -> aString (this release is "1.1.0")
       NONE, HARD, SOFT, SPACE, MARK, EVEN, ODD -> anInteger

    ** Class methods **

      * new(port_num [, modem_parameters]) -> aSerialPort
      * open(port_num [, modem_parameters]) -> aSerialPort
      * open(port_num [, modem_parameters]) {|aSerialPort| block} ->
                value of the block

        port_num -> anInteger: port number, 0 for first port which is
                      "/dev/ttyS0" on GNU/Linux and "COM1" on Windows,
                or  aString: file name of the device (example: "/dev/ttyS2")

        Optional modem_parameters:

        baud -> anInteger: from 50 to 256000, depends on platform.

        data_bits -> anInteger: from 5 to 8 (4 is allowed on Windows)

        stop_bits -> anInteger: 1 or 2 (1.5 is not supported)

        parity -> anInteger: SerialPort::NONE, SerialPort::EVEN,
                  SerialPort::ODD, SerialPort::MARK, SerialPort::SPACE
                  (MARK and SPACE are not supported on Posix)

        flow_control -> anInteger: SerialPort::NONE, SerialPort::SOFT,
                        SerialPort::HARD or
                        SerialPort::SOFT | SerialPort::HARD

        read_timeout -> anInteger: Read timeout in milliseconds. Rounded to
                        nearest tenth of a second on POSIX platforms

        write_timeout -> anInteger: Write timeout in milliseconds. Windows
                         platforms only

        Raise an argError on bad argument.

        SerialPort::new and SerialPort::open without a block return an
        instance of SerialPort.  SerialPort::open with a block passes
        a SerialPort to the block and closes it when the block exits
        (like File::open).


    ** Instance methods **

      * modem_params() -> aHash
      * modem_params=(aHash) -> aHash
      * get_modem_params() -> aHash
      * set_modem_params(aHash) -> aHash
      * set_modem_params(baudrate [, databits [, stopbits [, parity]]])

        Get and set the modem parameters.  Hash keys are "baud", "data_bits",
        "stop_bits", "parity", "flow_control", "read_timeout", and
        "write_timeout" (see above).

        Parameters not present in the hash or set to nil remain unchanged.
        Default parameter values for the set_modem_params method are:
        databits = 8, stopbits = 1, parity = (databits == 8 ?
        SerialPort::NONE : SerialPort::EVEN).

      * baud() -> anInteger
      * baud=(anInteger) -> anInteger
      * data_bits() -> 4, 5, 6, 7, or 8
      * data_bits=(anInteger) -> anInteger
      * stop_bits() -> 1 or 2
      * stop_bits=(anInteger) -> anInteger
      * parity() -> anInteger: SerialPort::NONE, SerialPort::EVEN,
          SerialPort::ODD, SerialPort::MARK, or SerialPort::SPACE
      * parity=(anInteger) -> anInteger

        Get and set the corresponding modem parameter.

      * flow_control() -> anInteger
      * flow_control=(anInteger) -> anInteger

        Get and set the flow control: SerialPort::NONE, SerialPort::HARD,
        SerialPort::SOFT, or (SerialPort::HARD | SerialPort::SOFT).

        Note: SerialPort::HARD mode is not supported on all platforms.
        SerialPort::HARD uses RTS/CTS handshaking; DSR/DTR is not
        supported.

      * read_timeout() -> anInteger
      * read_timeout=(anInteger) -> anInteger
      * write_timeout() -> anInteger
      * write_timeout=(anInteger) -> anInteger

        Get and set timeout values (in milliseconds) for reading and writing.
        A negative read timeout will return all the available data without
        waiting, a zero read timeout will not return until at least one
        byte is available, and a positive read timeout returns when the
        requested number of bytes is available or the interval between the
        arrival of two bytes exceeds the timeout value.

        Note: Read timeouts don't mix well with multi-threading.

        Note: Under Posix, write timeouts are not implemented.

      * break(time) -> nil

        Send a break for the given time.  

        time -> anInteger: tenths-of-a-second for the break.
        Note: Under Posix, this value is very approximate.

      * signals() -> aHash

        Return a hash with the state of each line status bit.  Keys are
        "rts", "dtr", "cts", "dsr", "dcd", and "ri".

        Note: Under Windows, the rts and dtr values are not included.

      * rts()
      * dtr()
      * cts()
      * dsr()
      * dcd()
      * ri() -> 0 or 1

      * rts=(0 or 1)
      * dtr=(0 or 1) -> 0 or 1

        Get and set the corresponding line status bit.

        Note: Under Windows, rts() and dtr() are not implemented.

-- License --

GPL

Guillaume Pierronnet <moumar@netcourrier.com>
Alan Stern <stern@rowland.harvard.edu>
Tobin Richard <tobin.richard@gmail.com>
Hector Parra <hector@hectorparra.com>
Ryan C. Payne <rpayne-oss@bullittsystems.com>
Tom Stokes <tomstokes@gmail.com>