rb232 0.2.5

data/COPYING

@@ -0,0 +1,19 @@
+Copyright (c) 2008 James Smith (james@floppy.org.uk)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,59 @@
+== RB232
+
+A simple serial port library for Ruby.
+
+Licensed under the MIT license (See COPYING file for details)
+
+Author: James Smith (james@floppy.org.uk / http://www.floppy.org.uk)
+
+Homepage: http://github.com/Floppy/rb232
+
+Documentation: http://docs.github.com/Floppy/rb232
+
+== ABOUT
+
+This library is a simple serial port library for Ruby.
+
+You may ask, why not just use ruby-serialport? Mainly because the GPL license
+it is under is too restrictive for my purposes. This code is under the MIT
+license, so you can do anything you like with it.
+
+== INSTALLATION
+
+1) Enable gems from gemcutter, if you haven't already done so:
+    > sudo gem install gemcutter
+    > sudo gem tumble
+
+2) Install gem
+    > sudo gem install rb232
+
+== STATUS
+
+Currently you can read from a serial port, but not write back. The code is only 
+tested on Linux - other unixes *may* work, Mac OSX *might* be ok, but Windows
+is right out for now. Watch this space for further developments!
+
+== USAGE
+
+The following code will read a 10-character string from the specified port,
+using the default port settings (9600/8/n/1/no flow control)
+
+      @port = RB232::Port.new('/dev/ttyUSB0')
+      message = @port.read_string(10)
+
+You can provide alternative settings when you create a new port:
+
+      RB232::Port.new('/dev/ttyS0', :baud_rate => 19200, 
+                                    :data_bits => 7, 
+                                    :parity => true, 
+                                    :stop_bits => 2,
+                                    :hardware_flow_control => true)
+
+See http://github.com/Floppy/rb232/tree/master/spec/port_spec.rb or RB232::Port
+documentation for more details.
+
+If you are using a simple text protocol over RS232, you can use the
+RB232::TextProtocol class to help you out. It automatically monitors the port
+and splits messages up by detecting separator characters. See 
+http://github.com/Floppy/rb232/tree/master/examples/listen.rb for an example of
+how to use this class.

data/examples/listen.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+dir = File.dirname(__FILE__) + '/../lib'
+$LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
+
+require 'rubygems'
+require 'rb232'
+require 'rb232/text_protocol'
+
+class SimpleClient
+  def update(message)
+    puts("Message received:")
+    puts(message)
+  end
+end
+
+require 'optparse'
+
+# Command-line options - just baud rate and separator for now
+options = {:port => '/dev/ttyS0', :baud_rate => 9600, :separator => "\n"}
+OptionParser.new do |opts|
+  opts.on("-p", "--serial_port SERIAL_PORT", "serial port") do |p|
+    options[:port] = p
+  end  
+  opts.on("-b", "--baud_rate BAUD_RATE", "baud rate") do |b|
+    options[:baud_rate] = b.to_i
+  end  
+  opts.on("-s", "--separator SEPARATOR", "message separator character") do |s|
+    options[:separator] = s
+  end  
+end.parse!
+
+port = RB232::Port.new(options[:port], :baud_rate => options[:baud_rate].to_i)
+
+protocol = RB232::TextProtocol.new(port, options[:separator])
+client = SimpleClient.new
+protocol.add_observer(client)
+
+# Start receiving messags
+protocol.start
+
+# Wait a while
+sleep(30)
+
+# OK, finish now
+protocol.stop

data/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+$CFLAGS = '-Wall ' + $CFLAGS
+
+create_makefile('rb232', 'src')

data/lib/rb232/text_protocol.rb

@@ -0,0 +1,67 @@
+require 'rb232'
+require 'observer'
+
+module RB232
+
+  # A helper class for RB232::Port which implements a simple text-based
+  # protocol on top of a serial port. Data is read from the serial port and split
+  # into individual messages based on a separator character.
+  #
+  # This class is Observable. Client code should implement an update(string) function
+  # add call TextProtocol#add_observer(self). When a complete message is received,
+  # the update() function will be called with the message string.  
+  class TextProtocol
+
+    include Observable
+
+    # Create a protocol object. _port_ should be a RB232::Port object.
+    # _separator_ is the character which separates messages in the text protocol,
+    # "\n" by default.
+    def initialize(port, separator = "\n")
+      @port = port
+      @separator = separator
+    end
+
+    # Separator character, as specified in TextProtocol#new
+    attr_reader :separator
+
+    # Port object, as specified in TextProtocol#new
+    attr_reader :port
+
+    # Begin processing incoming data from the serial port.
+    # A thread is started which monitors the port for data and detects
+    # complete messages.
+    # Call TextProtocol#stop to halt this process.
+    def start
+      @stop = false
+      @reader_thread = Thread.new {
+        buffer = ""
+        while (@stop == false)
+          new_string = ""
+          # Read in as much data as possible
+          begin
+            new_string = @port.read_string(255)
+            if (new_string.size > 0)
+              buffer += new_string
+              messages = buffer.split(@separator,2)
+              if messages.size > 1
+                changed
+                notify_observers(messages[0])
+                buffer = messages[1] || ""
+              end
+            end
+          end while (new_string.size > 0 && @stop == false)
+          sleep(0.5)
+        end
+      }
+    end
+
+    # Stop processing incoming data from the serial port.
+    def stop
+      @stop = true
+      @reader_thread.join
+    end
+
+  end
+
+end

data/src/port.c

@@ -0,0 +1,308 @@
+#include "port.h"
+#include "utility.h"
+
+#include <fcntl.h>
+#include <termios.h>
+#include <unistd.h>
+
+/* Module and class handles */
+VALUE RB232 = Qnil;
+VALUE RB232_Port = Qnil;
+
+/*
+ * Data structure for storing object data
+ */
+struct RB232_Port_Data {
+    /* Settings */
+    char* port_name;
+    int baud_rate;
+    int data_bits;
+    BOOL parity;
+    int stop_bits;
+    BOOL hardware_flow_control;
+    /* Internals */
+    int port_handle;
+    struct termios settings;
+};
+
+/* Helper for accessing port data */
+struct RB232_Port_Data* get_port_data(VALUE self) {
+    struct RB232_Port_Data *port_data;
+    Data_Get_Struct(self, struct RB232_Port_Data, port_data);
+    return port_data;
+};
+
+/*
+ * Port data deallocation
+ */
+VALUE rb232_port_data_free(void* p) {
+    struct RB232_Port_Data* port_data = p;
+    /* Close port */
+    close(port_data->port_handle);
+    /* Free memory */
+    free(port_data->port_name);
+    free(port_data);
+    /* Done */
+    return Qnil;
+}
+
+/*
+ * Object allocation
+ */
+VALUE rb232_port_alloc(VALUE klass) {
+    struct RB232_Port_Data* port_data = malloc(sizeof(struct RB232_Port_Data)); 
+    memset(port_data, 0, sizeof(struct RB232_Port_Data));
+    return Data_Wrap_Struct(klass, 0, rb232_port_data_free, port_data);
+}
+
+/*
+ * Object initialization. Takes a port name and a hash of port options.
+ */
+VALUE rb232_port_initialize_with_options(VALUE self, VALUE port, VALUE options) {
+    /* Get port data */
+    struct RB232_Port_Data *port_data = get_port_data(self);
+    /* Store port name */
+    int port_name_len = RSTRING(port)->len;
+    port_data->port_name = malloc(port_name_len + 1);
+    strcpy(port_data->port_name, RSTRING(port)->ptr);
+    /* Store options */
+    port_data->baud_rate = rbx_int_from_hash_or_default(options, ID2SYM(rb_intern("baud_rate")), 9600);
+    port_data->data_bits = rbx_int_from_hash_or_default(options, ID2SYM(rb_intern("data_bits")), 8);
+    port_data->parity = rbx_bool_from_hash_or_default(options, ID2SYM(rb_intern("parity")), FALSE);
+    port_data->stop_bits = rbx_int_from_hash_or_default(options, ID2SYM(rb_intern("stop_bits")), 1);
+    port_data->hardware_flow_control = rbx_bool_from_hash_or_default(options, ID2SYM(rb_intern("hardware_flow_control")), FALSE);
+    /* Open the serial port */
+    port_data->port_handle = open(port_data->port_name, O_RDWR | O_NOCTTY | O_NONBLOCK);
+    if (port_data->port_handle < 0) {
+        rb_raise(rb_eArgError, "couldn't open the specified port");
+    }
+    /* Set port settings */
+    port_data->settings.c_cflag = CRTSCTS | CLOCAL | CREAD;
+    /* Baud rate */
+    switch (port_data->baud_rate) {
+        case 0:
+            port_data->settings.c_cflag |= B0;
+            break;
+        case 50:
+            port_data->settings.c_cflag |= B50;
+            break;
+        case 75:
+            port_data->settings.c_cflag |= B75;
+            break;
+        case 110:
+            port_data->settings.c_cflag |= B110;
+            break;
+        case 134:
+            port_data->settings.c_cflag |= B134;
+            break;
+        case 150:
+            port_data->settings.c_cflag |= B150;
+            break;
+        case 200:
+            port_data->settings.c_cflag |= B200;
+            break;
+        case 300:
+            port_data->settings.c_cflag |= B300;
+            break;
+        case 600:
+            port_data->settings.c_cflag |= B600;
+            break;
+        case 1200:
+            port_data->settings.c_cflag |= B1200;
+            break;
+        case 1800:
+            port_data->settings.c_cflag |= B1800;
+            break;
+        case 2400:
+            port_data->settings.c_cflag |= B2400;
+            break;
+        case 4800:
+            port_data->settings.c_cflag |= B4800;
+            break;
+        case 9600:
+            port_data->settings.c_cflag |= B9600;
+            break;
+        case 19200:
+            port_data->settings.c_cflag |= B19200;
+            break;
+        case 38400:
+            port_data->settings.c_cflag |= B38400;
+            break;
+        case 57600:
+            port_data->settings.c_cflag |= B57600;
+            break;
+        default:
+            rb_raise(rb_eArgError, "baud_rate must be a valid value");
+    }
+    /* Data bits */
+    switch (port_data->data_bits) {
+        case 8:
+            port_data->settings.c_cflag |= CS8;
+            break;
+        case 7:
+            port_data->settings.c_cflag |= CS7;
+            break;
+        case 6:
+            port_data->settings.c_cflag |= CS6;
+            break;
+        case 5:
+            port_data->settings.c_cflag |= CS5;
+            break;
+        default:
+            rb_raise(rb_eArgError, "data_bits must be 5, 6, 7 or 8");
+    }    
+    /* Parity */
+    if (port_data->parity) port_data->settings.c_cflag |= PARENB;
+    /* Stop bits */
+    switch (port_data->stop_bits) {
+        case 2:
+            port_data->settings.c_cflag |= CSTOPB;
+            break;
+        case 1:
+            break;
+        default:
+            rb_raise(rb_eArgError, "stop_bits must be 1 or 2");
+    }
+    /* Flow control */
+    if (port_data->hardware_flow_control) port_data->settings.c_cflag |= CNEW_RTSCTS;
+    /* Other settings */
+    port_data->settings.c_iflag = IGNPAR | ICRNL;
+    port_data->settings.c_oflag = 0;
+    port_data->settings.c_lflag = ICANON;
+    /* Flush input buffer */
+    tcflush(port_data->port_handle, TCIFLUSH);
+    /* Apply settings to port */
+    tcsetattr(port_data->port_handle, TCSANOW, &port_data->settings);
+    /* Done */
+    return Qnil;
+}
+
+/*
+ * Create a Port object, using the port filename specified in _port_ (e.g. '/dev/ttyS0' or 'COM1').
+ *
+ * Valid options are :baud_rate (integer), :data_bits (integer), :parity
+ * (boolean), and :stop_bits (integer). Default values are 9600, 8, false, and 1 respectively.
+ *
+ * call-seq:
+ *   new(port, options = {})
+ *
+ */
+VALUE rb232_port_initialize(int argc, VALUE* argv, VALUE self) {
+    /* Only allow 1 or 2 arguments */
+    if (argc == 0 || argc >= 3) {
+        rb_raise(rb_eArgError, "wrong number of arguments (must be 1 or 2)");
+        return Qnil;
+    }
+    /* Get port name */
+    SafeStringValue(argv[0]);
+    VALUE port = argv[0];
+    /* Get options */
+    VALUE options = Qnil;
+    if (argc == 1)
+        options = rb_hash_new();
+    else
+        options = rb_convert_type(argv[1], T_HASH, "Hash", "to_hash");
+    /* Call real initialize function */
+    return rb232_port_initialize_with_options(self, port, options);
+}
+
+/*
+ * Get the port name (for instance, '/dev/ttyS0' or 'COM1'), as set in Port#new.
+ */
+VALUE rb232_port_get_port_name(VALUE self) {
+    /* Return baud rate */
+    return rb_str_new2(get_port_data(self)->port_name);
+}
+
+/*
+ * Get the baud rate, as set in the _options_ argument to Port#new.
+ */
+VALUE rb232_port_get_baud_rate(VALUE self) {
+    /* Return baud rate */
+    return rb_uint_new(get_port_data(self)->baud_rate);
+}
+
+/*
+ * Get the number of data bits, as set in the _options_ argument to Port#new.
+ */
+VALUE rb232_port_get_data_bits(VALUE self) {
+    /* Return baud rate */
+    return rb_uint_new(get_port_data(self)->data_bits);
+}
+
+/*
+ * Get the parity setting, as set in the _options_ argument to Port#new.
+ */
+VALUE rb232_port_get_parity(VALUE self) {
+    /* Return parity setting */
+    if (get_port_data(self)->parity == TRUE)
+        return Qtrue;
+    else
+        return Qfalse;
+}
+
+/*
+ * Get the number of stop bits, as set in the _options_ argument to Port#new.
+ */
+VALUE rb232_port_get_stop_bits(VALUE self) {
+    /* Return baud rate */
+    return rb_uint_new(get_port_data(self)->stop_bits);
+}
+
+/*
+ * Get the hardware flow control setting, as set in the _options_ argument to Port#new.
+ */
+VALUE rb232_port_get_hardware_flow_control(VALUE self) {
+    /* Return flow control setting */
+    if (get_port_data(self)->hardware_flow_control == TRUE)
+        return Qtrue;
+    else
+        return Qfalse;
+}
+
+/* 
+ * Read raw data from port
+ */
+int rb232_port_read(VALUE self, char* buffer, VALUE count) {
+    int bytes_to_read = NUM2INT(count);
+    if (bytes_to_read > 255)
+        rb_raise(rb_eArgError, "can't read more than 255 bytes at once");
+    return read(get_port_data(self)->port_handle, buffer, bytes_to_read);
+}
+
+/*
+ * Read up to _count_ raw byte values from the port.
+ * Returns an array of values. If no data is currently available, a zero-length
+ * array will be returned.
+ * Useful for binary protocols.
+ * call-seq:
+ *   read_bytes(count)
+ *
+ */
+VALUE rb232_port_read_bytes(VALUE self, VALUE count) {
+    char buffer[256];
+    int bytes_read = rb232_port_read(self, buffer, count);
+    VALUE data = rb_ary_new();
+    int i;
+    for (i=0; i<bytes_read; i++) {
+        rb_ary_push(data, INT2NUM(buffer[i]));
+    }
+    return data;
+}
+
+/*
+ * Read up to _count_ characters from the port.
+ * Returns a string. If no data is currently available, an empty string will be 
+ * returned.
+ * Useful for text-based protocols.
+ * call-seq:
+ *   read_string(count)
+ *
+ */
+VALUE rb232_port_read_string(VALUE self, VALUE count) {
+    char buffer[256];
+    int bytes_read = rb232_port_read(self, buffer, count);
+    if (bytes_read < 1) bytes_read = 0;
+    buffer[bytes_read] = 0;
+    return rb_str_new2(buffer);
+}

data/src/port.h

@@ -0,0 +1,70 @@
+#include "ruby.h"
+
+/* module RB232 */
+extern VALUE RB232;
+
+/*   class Port */
+extern VALUE RB232_Port;
+
+/* Allocator for Port class */
+VALUE rb232_port_alloc(VALUE klass);
+
+/*
+ * Create a Port object, using the port filename specified in _port_ (e.g. '/dev/ttyS0' or 'COM1').
+ *
+ * Valid options are :baud_rate (integer), :data_bits (integer), :parity
+ * (boolean), and :stop_bits (integer). Default values are 9600, 8, false, and 1 respectively.
+ *
+ * call-seq:
+ *   new(port, options = {})
+ *
+ */
+VALUE rb232_port_initialize(int argc, VALUE* argv, VALUE self);
+
+/*
+ * Get the port name (for instance, '/dev/ttyS0' or 'COM1'), as set in Port#new.
+ */
+VALUE rb232_port_get_port_name(VALUE self);
+
+/*
+ * Get the baud rate, as set in the _options_ argument to Port#new.
+ */
+VALUE rb232_port_get_baud_rate(VALUE self);
+
+/*
+ * Get the number of data bits, as set in the _options_ argument to Port#new.
+ */
+VALUE rb232_port_get_data_bits(VALUE self);
+
+/*
+ * Get the parity setting, as set in the _options_ argument to Port#new.
+ */
+VALUE rb232_port_get_parity(VALUE self);
+
+/*
+ * Get the number of stop bits, as set in the _options_ argument to Port#new.
+ */
+VALUE rb232_port_get_stop_bits(VALUE self);
+
+/*
+ * Get the hardware flow control setting, as set in the _options_ argument to Port#new.
+ */
+VALUE rb232_port_get_hardware_flow_control(VALUE self);
+
+/*
+ * Read _count_ raw byte values from the port.
+ * Returns an array of values. Useful for binary protocols.
+ * call-seq:
+ *   read_bytes(count)
+ *
+ */
+VALUE rb232_port_read_bytes(VALUE self, VALUE count);
+
+/*
+ * Read _count_ characters from the port.
+ * Returns a string. Useful for text-based protocols.
+ * call-seq:
+ *   read_string(count)
+ *
+ */
+VALUE rb232_port_read_string(VALUE self, VALUE count);

data/src/rb232.c

@@ -0,0 +1,21 @@
+#include "ruby.h"
+#include "port.h"
+
+/*
+ * Serial port communications. The class RB232::Port provides access to a hardware
+ * port on the local machine. Currently only Linux systems are supported.
+ */
+void Init_rb232() {
+    RB232 = rb_define_module("RB232");
+    RB232_Port = rb_define_class_under(RB232, "Port", rb_cObject);
+    rb_define_alloc_func(RB232_Port, rb232_port_alloc);
+    rb_define_method(RB232_Port, "initialize", rb232_port_initialize, -1); /* in port.c */
+    rb_define_method(RB232_Port, "port_name", rb232_port_get_port_name, 0); /* in port.c */
+    rb_define_method(RB232_Port, "baud_rate", rb232_port_get_baud_rate, 0); /* in port.c */
+    rb_define_method(RB232_Port, "data_bits", rb232_port_get_data_bits, 0); /* in port.c */
+    rb_define_method(RB232_Port, "parity", rb232_port_get_parity, 0); /* in port.c */
+    rb_define_method(RB232_Port, "stop_bits", rb232_port_get_stop_bits, 0); /* in port.c */
+    rb_define_method(RB232_Port, "hardware_flow_control", rb232_port_get_hardware_flow_control, 0); /* in port.c */
+    rb_define_method(RB232_Port, "read_bytes", rb232_port_read_bytes, 1); /* in port.c */
+    rb_define_method(RB232_Port, "read_string", rb232_port_read_string, 1); /* in port.c */
+}

data/src/utility.c

@@ -0,0 +1,30 @@
+#include "utility.h"
+
+/*
+ * Get a key from a hash, or if it's not there, use the default.
+ * A bit like doing hash[key] || default_val in Ruby.
+ * Integer version.
+ */
+int rbx_int_from_hash_or_default(VALUE hash, VALUE key, int default_val) {
+    VALUE data = (rb_hash_aref(hash, key));
+    if (data == Qnil)
+        return default_val;
+    else
+        return NUM2INT(data);
+}
+
+/*
+ * Get a key from a hash, or if it's not there, use the default.
+ * A bit like doing hash[key] || default_val in Ruby.
+ * Boolean version.
+ */
+BOOL rbx_bool_from_hash_or_default(VALUE hash, VALUE key, BOOL default_val) {
+    VALUE data = (rb_hash_aref(hash, key));
+    if (data == Qnil)
+        return default_val;
+    else
+        if (data == Qtrue)
+            return TRUE;
+        else
+            return FALSE;
+}

data/src/utility.h

@@ -0,0 +1,19 @@
+#include "ruby.h"
+
+#define BOOL char
+#define TRUE 1
+#define FALSE 0
+
+/*
+ * Get a key from a hash, or if it's not there, use the default.
+ * A bit like doing hash[key] || default_val in Ruby.
+ * Integer version.
+ */
+int rbx_int_from_hash_or_default(VALUE hash, VALUE key, int default_val);
+
+/*
+ * Get a key from a hash, or if it's not there, use the default.
+ * A bit like doing hash[key] || default_val in Ruby.
+ * Boolean version.
+ */
+BOOL rbx_bool_from_hash_or_default(VALUE hash, VALUE key, BOOL default_val);

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: rb232
+version: !ruby/object:Gem::Version 
+  version: 0.2.5
+platform: ruby
+authors: 
+- James Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-15 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: 
+email: james@floppy.org.uk
+executables: []
+
+extensions: 
+- extconf.rb
+extra_rdoc_files: []
+
+files: 
+- README
+- COPYING
+- extconf.rb
+- src/port.c
+- src/port.h
+- src/rb232.c
+- src/utility.c
+- src/utility.h
+- lib/rb232/text_protocol.rb
+- examples/listen.rb
+has_rdoc: true
+homepage: http://github.com/Floppy/rb232
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A simple serial port library for Ruby
+test_files: []
+