cehoffman-ruby-serialport 0.7.0

data/ext/serialport.c

@@ -0,0 +1,263 @@
+/* Ruby/SerialPort $Id$
+ * Guillaume Pierronnet <moumar@netcourrier.com>
+ * Alan Stern <stern@rowland.harvard.edu>
+ * Daniel E. Shipton <dshipton@redshiptechnologies.com>
+ * Chris Hoffman <cehoffman@gmail.com>
+ * 
+ * This code is hereby licensed for public consumption under either the
+ * GNU GPL v2 or greater.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * For documentation on serial programming, see the excellent:
+ * "Serial Programming Guide for POSIX Operating Systems"
+ * written Michael R. Sweet.
+ * http://www.easysw.com/~mike/serial/
+ */
+
+#include "serialport.h"
+
+VALUE cSerialPort; /* serial port class */
+
+static VALUE sp_set_data_rate(self, data_rate)
+   VALUE self, data_rate;
+{
+   VALUE argv[4];
+
+   argv[0] = data_rate;
+   argv[1] = argv[2] = argv[3] = Qnil;
+   sp_set_modem_params(4, argv, self);
+
+   return data_rate;
+}
+
+static VALUE sp_set_data_bits(self, data_bits)
+   VALUE self, data_bits;
+{
+   VALUE argv[4];
+
+   argv[1] = data_bits;
+   argv[0] = argv[2] = argv[3] = Qnil;
+   sp_set_modem_params(4, argv, self);
+
+   return data_bits;
+}
+
+static VALUE sp_set_stop_bits(self, stop_bits)
+   VALUE self, stop_bits;
+{
+   VALUE argv[4];
+
+   argv[2] = stop_bits;
+   argv[0] = argv[1] = argv[3] = Qnil;
+   sp_set_modem_params(4, argv, self);
+
+   return stop_bits;
+}
+
+static VALUE sp_set_parity(self, parity)
+   VALUE self, parity;
+{
+   VALUE argv[4];
+
+   argv[3] = parity;
+   argv[0] = argv[1] = argv[2] = Qnil;
+   sp_set_modem_params(4, argv, self);
+
+   return parity;
+}
+
+static VALUE sp_get_data_rate(self)
+   VALUE self;
+{
+   struct modem_params mp;
+
+   get_modem_params(self, &mp);
+
+   return INT2FIX(mp.data_rate);
+}
+
+static VALUE sp_get_data_bits(self)
+   VALUE self;
+{
+   struct modem_params mp;
+
+   get_modem_params(self, &mp);
+
+   return INT2FIX(mp.data_bits);
+}
+
+static VALUE sp_get_stop_bits(self)
+   VALUE self;
+{
+   struct modem_params mp;
+
+   get_modem_params(self, &mp);
+
+   return INT2FIX(mp.stop_bits);
+}
+
+static VALUE sp_get_parity(self)
+   VALUE self;
+{
+   struct modem_params mp;
+
+   get_modem_params(self, &mp);
+
+   return INT2FIX(mp.parity);
+}
+
+static VALUE sp_get_modem_params(self)
+   VALUE self;
+{
+   struct modem_params mp;
+   VALUE hash;
+
+   get_modem_params(self, &mp);
+
+   hash = rb_hash_new();
+
+   rb_hash_aset(hash, sBaud, INT2FIX(mp.data_rate));
+   rb_hash_aset(hash, sDataBits, INT2FIX(mp.data_bits));
+   rb_hash_aset(hash, sStopBits, INT2FIX(mp.stop_bits));
+   rb_hash_aset(hash, sParity, INT2FIX(mp.parity));
+
+   return hash;
+}
+
+static VALUE sp_get_cts(self)
+   VALUE self;
+{
+   struct line_signals ls;
+
+   get_line_signals_helper(self, &ls);
+
+   return INT2FIX(ls.cts);
+}
+
+static VALUE sp_get_dsr(self)
+   VALUE self;
+{
+   struct line_signals ls;
+
+   get_line_signals_helper(self, &ls);
+
+   return INT2FIX(ls.dsr);
+}
+
+static VALUE sp_get_dcd(self)
+   VALUE self;
+{
+   struct line_signals ls;
+
+   get_line_signals_helper(self, &ls);
+
+   return INT2FIX(ls.dcd);
+}
+
+static VALUE sp_get_ri(self)
+   VALUE self;
+{
+   struct line_signals ls;
+
+   get_line_signals_helper(self, &ls);
+
+   return INT2FIX(ls.ri);
+}
+
+static VALUE sp_signals(self)
+   VALUE self;
+{
+   struct line_signals ls;
+   VALUE hash;
+
+   get_line_signals_helper(self, &ls);
+
+   hash = rb_hash_new();
+
+#if !(defined(OS_MSWIN) || defined(OS_BCCWIN))
+   rb_hash_aset(hash, sRts, INT2FIX(ls.rts));
+   rb_hash_aset(hash, sDtr, INT2FIX(ls.dtr));
+#endif
+   rb_hash_aset(hash, sCts, INT2FIX(ls.cts));
+   rb_hash_aset(hash, sDsr, INT2FIX(ls.dsr));
+   rb_hash_aset(hash, sDcd, INT2FIX(ls.dcd));
+   rb_hash_aset(hash, sRi, INT2FIX(ls.ri));
+
+   return hash;
+}
+
+void Init_serialport()
+{
+   sBaud = rb_str_new2("baud");
+   sDataBits = rb_str_new2("data_bits");
+   sStopBits = rb_str_new2("stop_bits");
+   sParity = rb_str_new2("parity");
+   sRts = rb_str_new2("rts");
+   sDtr = rb_str_new2("dtr");
+   sCts = rb_str_new2("cts");
+   sDsr = rb_str_new2("dsr");
+   sDcd = rb_str_new2("dcd");
+   sRi = rb_str_new2("ri");
+
+   rb_gc_register_address(&sBaud);
+   rb_gc_register_address(&sDataBits);
+   rb_gc_register_address(&sStopBits);
+   rb_gc_register_address(&sParity);
+   rb_gc_register_address(&sRts);
+   rb_gc_register_address(&sDtr);
+   rb_gc_register_address(&sCts);
+   rb_gc_register_address(&sDsr);
+   rb_gc_register_address(&sDcd);
+   rb_gc_register_address(&sRi);
+
+   cSerialPort = rb_define_class("SerialPort", rb_cIO);
+   rb_define_singleton_method(cSerialPort, "create", sp_create, 1);
+
+   rb_define_method(cSerialPort, "get_modem_params", sp_get_modem_params, 0);
+   rb_define_method(cSerialPort, "set_modem_params", sp_set_modem_params, -1);
+   rb_define_method(cSerialPort, "modem_params", sp_get_modem_params, 0);
+   rb_define_method(cSerialPort, "modem_params=", sp_set_modem_params, -1);
+   rb_define_method(cSerialPort, "baud", sp_get_data_rate, 0);
+   rb_define_method(cSerialPort, "baud=", sp_set_data_rate, 1);
+   rb_define_method(cSerialPort, "data_bits", sp_get_data_bits, 0);
+   rb_define_method(cSerialPort, "data_bits=", sp_set_data_bits, 1);
+   rb_define_method(cSerialPort, "stop_bits", sp_get_stop_bits, 0);
+   rb_define_method(cSerialPort, "stop_bits=", sp_set_stop_bits, 1);
+   rb_define_method(cSerialPort, "parity", sp_get_parity, 0);
+   rb_define_method(cSerialPort, "parity=", sp_set_parity, 1);
+
+   rb_define_method(cSerialPort, "flow_control=", sp_set_flow_control, 1);
+   rb_define_method(cSerialPort, "flow_control", sp_get_flow_control, 0);
+
+   rb_define_method(cSerialPort, "read_timeout", sp_get_read_timeout, 0);
+   rb_define_method(cSerialPort, "read_timeout=", sp_set_read_timeout, 1);
+   rb_define_method(cSerialPort, "write_timeout", sp_get_write_timeout, 0);
+   rb_define_method(cSerialPort, "write_timeout=", sp_set_write_timeout, 1);
+
+   rb_define_method(cSerialPort, "break", sp_break, 1);
+
+   rb_define_method(cSerialPort, "signals", sp_signals, 0);
+   rb_define_method(cSerialPort, "get_signals", sp_signals, 0);
+   rb_define_method(cSerialPort, "rts", sp_get_rts, 0);
+   rb_define_method(cSerialPort, "rts=", sp_set_rts, 1);
+   rb_define_method(cSerialPort, "dtr", sp_get_dtr, 0);
+   rb_define_method(cSerialPort, "dtr=", sp_set_dtr, 1);
+   rb_define_method(cSerialPort, "cts", sp_get_cts, 0);
+   rb_define_method(cSerialPort, "dsr", sp_get_dsr, 0);
+   rb_define_method(cSerialPort, "dcd", sp_get_dcd, 0);
+   rb_define_method(cSerialPort, "ri", sp_get_ri, 0);
+
+   rb_define_const(cSerialPort, "NONE", INT2FIX(NONE));
+   rb_define_const(cSerialPort, "HARD", INT2FIX(HARD));
+   rb_define_const(cSerialPort, "SOFT", INT2FIX(SOFT));
+
+   rb_define_const(cSerialPort, "SPACE", INT2FIX(SPACE));
+   rb_define_const(cSerialPort, "MARK", INT2FIX(MARK));
+   rb_define_const(cSerialPort, "EVEN", INT2FIX(EVEN));
+   rb_define_const(cSerialPort, "ODD", INT2FIX(ODD));
+
+   rb_define_const(cSerialPort, "VERSION", rb_str_new2(RUBY_SERIAL_PORT_VERSION));
+}

data/ext/serialport.h

@@ -0,0 +1,83 @@
+/* Ruby/SerialPort $Id$
+ * Guillaume Pierronnet <moumar@netcourrier.com>
+ * Alan Stern <stern@rowland.harvard.edu>
+ * Daniel E. Shipton <dshipton@redshiptechnologies.com>
+ * Chris Hoffman <cehoffman@gmail.com>
+ *
+ * This code is hereby licensed for public consumption under either the
+ * GNU GPL v2 or greater.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * For documentation on serial programming, see the excellent:
+ * "Serial Programming Guide for POSIX Operating Systems"
+ * written Michael R. Sweet.
+ * http://www.easysw.com/~mike/serial/
+ */
+
+#ifndef _RUBY_SERIAL_PORT_H_
+#define _RUBY_SERIAL_PORT_H_
+
+#define RUBY_SERIAL_PORT_VERSION   "0.7.0"
+
+#include <ruby.h>    /* ruby inclusion */
+#include <rubyio.h>  /* ruby io inclusion */
+
+struct modem_params
+{
+   int data_rate;
+   int data_bits;
+   int stop_bits;
+   int parity;
+};
+
+struct line_signals
+{
+   int rts;
+   int dtr;
+   int cts;
+   int dsr;
+   int dcd;
+   int ri;
+};
+
+#define NONE   0
+#define HARD   1
+#define SOFT   2
+
+#if defined(OS_MSWIN) || defined(OS_BCCWIN)
+   #define SPACE  SPACEPARITY
+   #define MARK   MARKPARITY
+   #define EVEN   EVENPARITY
+   #define ODD    ODDPARITY
+#else
+   #define SPACE  0
+   #define MARK   0
+   #define EVEN   1
+   #define ODD    2
+#endif
+
+static VALUE sBaud, sDataBits, sStopBits, sParity; /* strings */
+static VALUE sRts, sDtr, sCts, sDsr, sDcd, sRi;
+
+
+VALUE sp_create(VALUE class, VALUE _port);
+VALUE sp_set_modem_params(int argc, VALUE *argv, VALUE self);
+void get_modem_params(VALUE self, struct modem_params *mp);
+VALUE sp_set_flow_control(VALUE self, VALUE val);
+VALUE sp_get_flow_control(VALUE self);
+VALUE sp_set_read_timeout(VALUE self, VALUE val);
+VALUE sp_get_read_timeout(VALUE self);
+VALUE sp_set_write_timeout(VALUE self, VALUE val);
+VALUE sp_get_write_timeout(VALUE self);
+VALUE sp_break(VALUE self, VALUE time);
+void get_line_signals_helper(VALUE obj, struct line_signals *ls);
+VALUE set_signal(VALUE obj, VALUE val, int sig);
+VALUE sp_set_rts(VALUE self, VALUE val);
+VALUE sp_set_dtr(VALUE self, VALUE val);
+VALUE sp_get_rts(VALUE self);
+VALUE sp_get_dtr(VALUE self);
+
+#endif

data/ext/win_serialport_impl.c

@@ -0,0 +1,616 @@
+/* Ruby/SerialPort $Id$
+ * Guillaume Pierronnet <moumar@netcourrier.com>
+ * Alan Stern <stern@rowland.harvard.edu>
+ * Daniel E. Shipton <dshipton@redshiptechnologies.com>
+ *
+ * This code is hereby licensed for public consumption under either the
+ * GNU GPL v2 or greater.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * For documentation on serial programming, see the excellent:
+ * "Serial Programming Guide for POSIX Operating Systems"
+ * written Michael R. Sweet.
+ * http://www.easysw.com/~mike/serial/
+ */
+
+#include "serialport.h"
+
+#if defined(OS_MSWIN) || defined(OS_BCCWIN)
+
+#include <stdio.h>   /* Standard input/output definitions */
+#include <io.h>      /* Low-level I/O definitions */
+#include <fcntl.h>   /* File control definitions */
+#include <windows.h> /* Windows standard function definitions */
+
+#ifndef RB_SERIAL_EXPORT
+#define RB_SERIAL_EXPORT __declspec(dllexport)
+//#define RB_SERIAL_EXPORT 
+#endif
+
+static char sGetCommState[] = "GetCommState";
+static char sSetCommState[] = "SetCommState";
+static char sGetCommTimeouts[] = "GetCommTimeouts";
+static char sSetCommTimeouts[] = "SetCommTimeouts";
+
+
+static HANDLE get_handle_helper(obj)
+   VALUE obj;
+{
+   OpenFile *fptr;
+
+   GetOpenFile(obj, fptr);
+   return (HANDLE) _get_osfhandle(fileno(fptr->f));
+}
+
+VALUE RB_SERIAL_EXPORT sp_create_impl(class, _port)
+   VALUE class, _port;
+{
+   OpenFile *fp;
+   int fd;
+   HANDLE fh;
+   int num_port;
+   char *port;
+   char *ports[] = {
+      "COM1", "COM2", "COM3", "COM4",
+      "COM5", "COM6", "COM7", "COM8"
+   };
+   //int new_fd;
+
+   DCB dcb;
+
+   NEWOBJ(sp, struct RFile);
+   rb_secure(4);
+   OBJSETUP(sp, class, T_FILE);
+   MakeOpenFile((VALUE) sp, fp);
+
+   switch(TYPE(_port))
+   {
+      case T_FIXNUM:
+         num_port = FIX2INT(_port);
+         if (num_port < 0 || num_port > sizeof(ports) / sizeof(ports[0]))
+         {
+            rb_raise(rb_eArgError, "illegal port number");
+         }
+         port = ports[num_port];
+         break;
+
+      case T_STRING:
+         Check_SafeStr(_port);
+         port = RSTRING(_port)->ptr;
+         break;
+
+      default:
+         rb_raise(rb_eTypeError, "wrong argument type");
+         break;
+   }
+
+   printf("SerialPort => %s\n", port);
+   fd = open(port, O_BINARY | O_RDWR);
+   printf("        fd => %i\n", fd);
+   if (fd == -1)
+      rb_sys_fail(port);
+   fh = (HANDLE) _get_osfhandle(fd);
+   printf("        fh => %i\n", fh);
+   if (SetupComm(fh, 1024, 1024) == 0)
+   {
+      close(fd);
+      rb_raise(rb_eArgError, "not a serial port");
+   }
+
+   dcb.DCBlength = sizeof(dcb);
+   if (GetCommState(fh, &dcb) == 0)
+   {
+      close(fd);
+      rb_sys_fail(sGetCommState);
+   }
+   dcb.fBinary = TRUE;
+   dcb.fParity = FALSE;
+   dcb.fOutxDsrFlow = FALSE;
+   dcb.fDtrControl = DTR_CONTROL_ENABLE;
+   dcb.fDsrSensitivity = FALSE;
+   dcb.fTXContinueOnXoff = FALSE;
+   dcb.fErrorChar = FALSE;
+   dcb.fNull = FALSE;
+   dcb.fAbortOnError = FALSE;
+   dcb.XonChar = 17;
+   dcb.XoffChar = 19;
+   if (SetCommState(fh, &dcb) == 0)
+   {
+      close(fd);
+      rb_sys_fail(sSetCommState);
+   }
+
+   errno = 0;
+   fp->mode = FMODE_READWRITE | FMODE_BINMODE | FMODE_SYNC;
+   fp->f = fdopen(fd, "rb+");
+   return (VALUE) sp;
+}
+
+VALUE RB_SERIAL_EXPORT sp_set_modem_params_impl(argc, argv, self)
+   int argc;
+   VALUE *argv, self;
+{
+   HANDLE fh;
+   DCB dcb;
+   VALUE _data_rate, _data_bits, _parity, _stop_bits;
+   int use_hash = 0;
+   int data_rate, data_bits, parity;
+
+   if (argc == 0)
+   {
+      return self;
+   }
+   if (argc == 1 && T_HASH == TYPE(argv[0]))
+   {
+      use_hash = 1;
+      _data_rate = rb_hash_aref(argv[0], sBaud);
+      _data_bits = rb_hash_aref(argv[0], sDataBits);
+      _stop_bits = rb_hash_aref(argv[0], sStopBits);
+      _parity = rb_hash_aref(argv[0], sParity);
+   }
+
+   fh = get_handle_helper(self);
+   dcb.DCBlength = sizeof(dcb);
+   if (GetCommState(fh, &dcb) == 0)
+   {
+      rb_sys_fail(sGetCommState);
+   }
+
+   if (!use_hash)
+   {
+      _data_rate = argv[0];
+   }
+
+   if (NIL_P(_data_rate))
+   {
+      goto SkipDataRate;
+   }
+
+   Check_Type(_data_rate, T_FIXNUM);
+
+   data_rate = FIX2INT(_data_rate);
+   switch (data_rate)
+   {
+      case 110:
+      case 300:
+      case 600:
+      case 1200:
+      case 2400:
+      case 4800:
+      case 9600:
+      case 14400:
+      case 19200:
+      case 38400:
+      case 56000:
+      case 57600:
+      case 115200:
+      case 128000:
+      case 256000:
+         dcb.BaudRate = data_rate;
+         break;
+
+      default:
+         rb_raise(rb_eArgError, "unknown baud rate");
+         break;
+   }
+
+   SkipDataRate:
+
+   if (!use_hash)
+   {
+      _data_bits = (argc >= 2 ? argv[1] : INT2FIX(8));
+   }
+
+   if (NIL_P(_data_bits))
+   {
+      goto SkipDataBits;
+   }
+
+   Check_Type(_data_bits, T_FIXNUM);
+
+   data_bits = FIX2INT(_data_bits);
+   if (4 <= data_bits && data_bits <= 8)
+   {
+      dcb.ByteSize = data_bits;
+   }
+   else
+   {
+      rb_raise(rb_eArgError, "unknown character size");
+   }
+
+   SkipDataBits:
+
+   if (!use_hash)
+   {
+      _stop_bits = (argc >= 3 ? argv[2] : INT2FIX(1));
+   }
+
+   if (NIL_P(_stop_bits))
+   {
+      goto SkipStopBits;
+   }
+
+   Check_Type(_stop_bits, T_FIXNUM);
+
+   switch (FIX2INT(_stop_bits))
+   {
+      case 1:
+         dcb.StopBits = ONESTOPBIT;
+         break;
+      case 2:
+         dcb.StopBits = TWOSTOPBITS;
+         break;
+      default:
+         rb_raise(rb_eArgError, "unknown number of stop bits");
+         break;
+   }
+
+   SkipStopBits:
+
+   if (!use_hash)
+   {
+      _parity = (argc >= 4 ? argv[3] : (dcb.ByteSize == 8 ?
+               INT2FIX(NOPARITY) : INT2FIX(EVENPARITY)));
+   }
+
+   if (NIL_P(_parity))
+   {
+      goto SkipParity;
+   }
+
+   Check_Type(_parity, T_FIXNUM);
+
+   parity = FIX2INT(_parity);
+   switch (parity)
+   {
+      case EVENPARITY:
+      case ODDPARITY:
+      case MARKPARITY:
+      case SPACEPARITY:
+      case NOPARITY:
+         dcb.Parity = parity;
+         break;
+
+      default:
+         rb_raise(rb_eArgError, "unknown parity");
+         break;
+   }
+
+   SkipParity:
+
+   if (SetCommState(fh, &dcb) == 0)
+   {
+      rb_sys_fail(sSetCommState);
+   }
+
+   return argv[0];
+}
+
+void RB_SERIAL_EXPORT get_modem_params_impl(self, mp)
+   VALUE self;
+   struct modem_params *mp;
+{
+   HANDLE fh;
+   DCB dcb;
+
+   fh = get_handle_helper(self);
+   dcb.DCBlength = sizeof(dcb);
+   if (GetCommState(fh, &dcb) == 0)
+   {
+      rb_sys_fail(sGetCommState);
+   }
+
+   mp->data_rate = dcb.BaudRate;
+   mp->data_bits = dcb.ByteSize;
+   mp->stop_bits = (dcb.StopBits == ONESTOPBIT ? 1 : 2);
+   mp->parity = dcb.Parity;
+}
+
+VALUE RB_SERIAL_EXPORT sp_set_flow_control_impl(self, val)
+   VALUE self, val;
+{
+   HANDLE fh;
+   int flowc;
+   DCB dcb;
+
+   Check_Type(val, T_FIXNUM);
+
+   fh = get_handle_helper(self);
+   dcb.DCBlength = sizeof(dcb);
+   if (GetCommState(fh, &dcb) == 0)
+   {
+      rb_sys_fail(sGetCommState);
+   }
+
+   flowc = FIX2INT(val);
+   if (flowc & HARD)
+   {
+      dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
+      dcb.fOutxCtsFlow = TRUE;
+   }
+   else
+   {
+      dcb.fRtsControl = RTS_CONTROL_ENABLE;
+      dcb.fOutxCtsFlow = FALSE;
+   }
+
+   if (flowc & SOFT)
+   {
+      dcb.fOutX = dcb.fInX = TRUE;
+   }
+   else
+   {
+      dcb.fOutX = dcb.fInX = FALSE;
+   }
+
+   if (SetCommState(fh, &dcb) == 0)
+   {
+      rb_sys_fail(sSetCommState);
+   }
+
+   return val;
+}
+
+VALUE RB_SERIAL_EXPORT sp_get_flow_control_impl(self)
+   VALUE self;
+{
+   HANDLE fh;
+   int ret;
+   DCB dcb;
+
+   fh = get_handle_helper(self);
+   dcb.DCBlength = sizeof(dcb);
+   if (GetCommState(fh, &dcb) == 0)
+   {
+      rb_sys_fail(sGetCommState);
+   }
+
+   ret = 0;
+   if (dcb.fOutxCtsFlow)
+   {
+      ret += HARD;
+   }
+
+   if (dcb.fOutX)
+   {
+      ret += SOFT;
+   }
+
+   return INT2FIX(ret);
+}
+
+VALUE RB_SERIAL_EXPORT sp_set_read_timeout_impl(self, val)
+   VALUE self, val;
+{
+   int timeout;
+   HANDLE fh;
+   COMMTIMEOUTS ctout;
+
+   Check_Type(val, T_FIXNUM);
+   timeout = FIX2INT(val);
+
+   fh = get_handle_helper(self);
+   if (GetCommTimeouts(fh, &ctout) == 0)
+   {
+      rb_sys_fail(sGetCommTimeouts);
+   }
+
+   if (timeout < 0)
+   {
+      ctout.ReadIntervalTimeout = MAXDWORD;
+      ctout.ReadTotalTimeoutMultiplier = 0;
+      ctout.ReadTotalTimeoutConstant = 0;
+   }
+   else if (timeout == 0)
+   {
+      ctout.ReadIntervalTimeout = MAXDWORD;
+      ctout.ReadTotalTimeoutMultiplier = MAXDWORD;
+      ctout.ReadTotalTimeoutConstant = MAXDWORD - 1;
+   }
+   else
+   {
+      ctout.ReadIntervalTimeout = timeout;
+      ctout.ReadTotalTimeoutMultiplier = 0;
+      ctout.ReadTotalTimeoutConstant = timeout;
+   }
+
+   if (SetCommTimeouts(fh, &ctout) == 0)
+   {
+      rb_sys_fail(sSetCommTimeouts);
+   }
+
+   return val;
+}
+
+VALUE RB_SERIAL_EXPORT sp_get_read_timeout_impl(self)
+   VALUE self;
+{
+   HANDLE fh;
+   COMMTIMEOUTS ctout;
+
+   fh = get_handle_helper(self);
+   if (GetCommTimeouts(fh, &ctout) == 0)
+   {
+      rb_sys_fail(sGetCommTimeouts);
+   }
+
+   switch (ctout.ReadTotalTimeoutConstant)
+   {
+      case 0:
+         return INT2FIX(-1);
+      case MAXDWORD:
+         return INT2FIX(0);
+   }
+
+   return INT2FIX(ctout.ReadTotalTimeoutConstant);
+}
+
+VALUE RB_SERIAL_EXPORT sp_set_write_timeout_impl(self, val)
+   VALUE self, val;
+{
+   int timeout;
+   HANDLE fh;
+   COMMTIMEOUTS ctout;
+
+   Check_Type(val, T_FIXNUM);
+   timeout = FIX2INT(val);
+
+   fh = get_handle_helper(self);
+   if (GetCommTimeouts(fh, &ctout) == 0)
+   {
+      rb_sys_fail(sGetCommTimeouts);
+   }
+
+   if (timeout <= 0)
+   {
+      ctout.WriteTotalTimeoutMultiplier = 0;
+      ctout.WriteTotalTimeoutConstant = 0;
+   }
+   else
+   {
+      ctout.WriteTotalTimeoutMultiplier = timeout;
+      ctout.WriteTotalTimeoutConstant = 0;
+   }
+
+   if (SetCommTimeouts(fh, &ctout) == 0)
+   {
+      rb_sys_fail(sSetCommTimeouts);
+   }
+
+   return val;
+}
+
+VALUE RB_SERIAL_EXPORT sp_get_write_timeout_impl(self)
+   VALUE self;
+{
+   HANDLE fh;
+   COMMTIMEOUTS ctout;
+
+   fh = get_handle_helper(self);
+   if (GetCommTimeouts(fh, &ctout) == 0)
+   {
+      rb_sys_fail(sGetCommTimeouts);
+   }
+
+   return INT2FIX(ctout.WriteTotalTimeoutMultiplier);
+}
+
+static void delay_ms(time)
+   int time;
+{
+   HANDLE ev;
+
+   ev = CreateEvent(NULL, FALSE, FALSE, NULL);
+   if (!ev)
+   {
+      rb_sys_fail("CreateEvent");
+   }
+
+   if (WaitForSingleObject(ev, time) == WAIT_FAILED)
+   {
+      rb_sys_fail("WaitForSingleObject");
+   }
+
+   CloseHandle(ev);
+}
+
+VALUE RB_SERIAL_EXPORT sp_break_impl(self, time)
+   VALUE self, time;
+{
+   HANDLE fh;
+
+   Check_Type(time, T_FIXNUM);
+
+   fh = get_handle_helper(self);
+   if (SetCommBreak(fh) == 0)
+   {
+      rb_sys_fail("SetCommBreak");
+   }
+
+   delay_ms(FIX2INT(time) * 100);
+   ClearCommBreak(fh);
+
+   return Qnil;
+}
+
+void RB_SERIAL_EXPORT get_line_signals_helper(obj, ls)
+   VALUE obj;
+   struct line_signals *ls;
+{
+   HANDLE fh;
+   int status;
+
+   fh = get_handle_helper(obj);
+   if (GetCommModemStatus(fh, &status) == 0)
+   {
+      rb_sys_fail("GetCommModemStatus");
+   }
+
+   ls->cts = (status & MS_CTS_ON ? 1 : 0);
+   ls->dsr = (status & MS_DSR_ON ? 1 : 0);
+   ls->dcd = (status & MS_RLSD_ON ? 1 : 0);
+   ls->ri  = (status & MS_RING_ON ? 1 : 0);
+}
+
+static VALUE set_signal(obj, val, sigoff, sigon)
+   VALUE obj,val;
+   int sigoff, sigon;
+{
+   HANDLE fh;
+   int set, sig;
+
+   Check_Type(val, T_FIXNUM);
+   fh = get_handle_helper(obj);
+
+   set = FIX2INT(val);
+   if (set == 0)
+   {
+      sig = sigoff;
+   }
+   else if (set == 1)
+   {
+      sig = sigon;
+   }
+   else
+   {
+      rb_raise(rb_eArgError, "invalid value");
+   }
+
+   if (EscapeCommFunction(fh, sig) == 0)
+   {
+      rb_sys_fail("EscapeCommFunction");
+   }
+
+   return val;
+}
+
+VALUE RB_SERIAL_EXPORT sp_set_rts_impl(self, val)
+   VALUE self, val;
+{
+   return set_signal(self, val, CLRRTS, SETRTS);
+}
+
+VALUE RB_SERIAL_EXPORT sp_set_dtr_impl(self, val)
+   VALUE self, val;
+{
+   return set_signal(self, val, CLRDTR, SETDTR);
+}
+
+VALUE RB_SERIAL_EXPORT sp_get_rts_impl(self)
+   VALUE self;
+{
+   rb_notimplement();
+   return self;
+}
+
+VALUE RB_SERIAL_EXPORT sp_get_dtr_impl(self)
+   VALUE self;
+{
+   rb_notimplement();
+   return self;
+}
+
+#endif /* defined(OS_MSWIN) || defined(OS_BCCWIN) */