Floppy-rb232 0.2.0

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,54 @@
+== 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
+
+== 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 github, if you haven't already done so (rubygems >= 1.2):
+    > sudo gem sources -a http://gems.github.com
+
+2) Install gem
+    > sudo gem install Floppy-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)
+
+      @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)
+
+If you are using a simple text protocol over RS232, you can use the TextProtocol
+class to help you out. It automatically monitors the port and splits messages
+up by detecting separator characters. See examples/listen.rb for an example of
+how to use this class.
+
+See http://github.com/Floppy/rb232/tree/master/spec/port_spec.rb for more
+details.

data/examples/listen.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+dir = File.dirname(__FILE__) + '/../lib'
+$LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
+
+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
+  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])
+
+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,2 @@
+require 'mkmf'
+create_makefile('rb232', 'src')

data/lib/rb232/text_protocol.rb

@@ -0,0 +1,41 @@
+require 'rb232'
+require 'observer'
+
+module RB232
+
+  class TextProtocol
+
+    include Observable
+
+    def initialize(port, separator = "\n")
+      @port = port
+      @separator = separator
+    end
+
+    attr_reader :separator
+    attr_reader :port
+
+    def start
+      @stop = false
+      @reader_thread = Thread.new {
+        buffer = ""
+        while (@stop == false)
+          buffer += @port.read_string(1)
+          messages = buffer.split(@separator,3)
+          if messages.size > 1
+            changed
+            notify_observers(messages[0])
+            buffer = ""
+          end
+        end
+      }
+    end
+
+    def stop
+      @stop = true
+      @reader_thread.join
+    end
+
+  end
+
+end

data/src/port.c

@@ -0,0 +1,254 @@
+#include "port.h"
+#include "utility.h"
+
+#include <fcntl.h>
+#include <termios.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;
+    /* 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);
+}
+
+/*
+ * 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);
+    /* Open the serial port */
+    port_data->port_handle = open(port_data->port_name, O_RDWR | O_NOCTTY);
+    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;
+        default:
+            rb_raise(rb_eArgError, "baud_rate must be a valid value");
+    }
+    port_data->settings.c_cflag |= B9600;
+    /* 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");
+    }
+    /* 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;
+}
+
+/*
+ * This function implements a default argument for initialize().
+ * Equivalent Ruby would be def initialize(port, options = {}).
+ * This function calls the _with_options version, providing an empty
+ * hash if one is not passed in.
+ */
+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);
+}
+
+/*     def port_name */
+VALUE rb232_port_get_port_name(VALUE self) {
+    /* Return baud rate */
+    return rb_str_new2(get_port_data(self)->port_name);
+}
+
+/*     def baud_rate */
+VALUE rb232_port_get_baud_rate(VALUE self) {
+    /* Return baud rate */
+    return rb_uint_new(get_port_data(self)->baud_rate);
+}
+
+/*     def data_bits */
+VALUE rb232_port_get_data_bits(VALUE self) {
+    /* Return baud rate */
+    return rb_uint_new(get_port_data(self)->data_bits);
+}
+
+/*     def parity */
+VALUE rb232_port_get_parity(VALUE self) {
+    /* Return baud rate */
+    if (get_port_data(self)->parity == TRUE)
+        return Qtrue;
+    else
+        return Qfalse;
+}
+
+/*     def stop_bits */
+VALUE rb232_port_get_stop_bits(VALUE self) {
+    /* Return baud rate */
+    return rb_uint_new(get_port_data(self)->stop_bits);
+}
+
+/* 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);
+}
+
+/*     def 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]));
+    }
+}
+
+/*     def read_string(count) */
+VALUE rb232_port_read_string(VALUE self, VALUE count) {
+    char buffer[256];
+    int bytes_read = rb232_port_read(self, buffer, count);
+    buffer[bytes_read] = 0;
+    return rb_str_new2(buffer);
+}

data/src/port.h

@@ -0,0 +1,34 @@
+#include "ruby.h"
+
+/* module RB232 */
+extern VALUE RB232;
+
+/*   class Port */
+extern VALUE RB232_Port;
+
+/* Allocator for Port class */
+VALUE rb232_port_alloc(VALUE klass);
+
+/*     def initialize(options = {}) */
+VALUE rb232_port_initialize(int argc, VALUE* argv, VALUE self);
+
+/*     def port_name */
+VALUE rb232_port_get_port_name(VALUE self);
+
+/*     def baud_rate */
+VALUE rb232_port_get_baud_rate(VALUE self);
+
+/*     def data_bits */
+VALUE rb232_port_get_data_bits(VALUE self);
+
+/*     def parity */
+VALUE rb232_port_get_parity(VALUE self);
+
+/*     def stop_bits */
+VALUE rb232_port_get_stop_bits(VALUE self);
+
+/*     def read_bytes(count) */
+VALUE rb232_port_read_bytes(VALUE self, VALUE count);
+
+/*     def 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"
+
+/*
+ * Library initialization.
+ * Registers all classes and methods with the Ruby interpreter.
+ * Called automatically on require 'rb232'.
+ */
+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);
+    rb_define_method(RB232_Port, "port_name", rb232_port_get_port_name, 0);
+    rb_define_method(RB232_Port, "baud_rate", rb232_port_get_baud_rate, 0);
+    rb_define_method(RB232_Port, "data_bits", rb232_port_get_data_bits, 0);
+    rb_define_method(RB232_Port, "parity", rb232_port_get_parity, 0);
+    rb_define_method(RB232_Port, "stop_bits", rb232_port_get_stop_bits, 0);
+    rb_define_method(RB232_Port, "read_bytes", rb232_port_read_bytes, 1);
+    rb_define_method(RB232_Port, "read_string", rb232_port_read_string, 1);
+}

data/src/utility.c

@@ -0,0 +1,20 @@
+#include "utility.h"
+
+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);
+}
+
+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,62 @@
+--- !ruby/object:Gem::Specification 
+name: Floppy-rb232
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- James Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-19 00:00:00 -07: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: false
+homepage: http://github.com/Floppy/rb232
+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.2.0
+signing_key: 
+specification_version: 2
+summary: A simple serial port library for Ruby
+test_files: []
+