levinalex-serial_interface 0.2.3

data/History.txt

@@ -0,0 +1,3 @@
+== 0.3.0 / 2008-10-12
+  * initial release
+

data/Manifest.txt

@@ -0,0 +1,11 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/protocol/rca2006.rb
+lib/serial_interface.rb
+lib/serial_packet.rb
+serial_interface.gemspec
+test/test_serial_interface.rb
+test/test_serial_io.rb
+test/test_serial_packets.rb

data/README.txt

@@ -0,0 +1,54 @@
+serial_interface
+    by Levin Alexander
+    http://levinalex.net/
+
+== DESCRIPTION:
+  
+serial_interface intends to be a small library that makes it easy
+to define packet based protocols over a serial link (RS232) in a
+declarative fashion.
+
+== FEATURES/PROBLEMS:
+  
+* remove dependency on traits
+* fix all the warnings
+* add some tests that test the actual functionality
+* improve the interface
+* improve the architecture
+
+== SYNOPSIS:
+
+  nothing written yet
+
+== REQUIREMENTS:
+
+* traits 0.8.1
+
+== INSTALL:
+
+* not yet written
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2006-2008 Levin Alexander
+
+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/Rakefile

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'hoe'
+require 'spec/rake/spectask'
+
+require './lib/serial_interface.rb'
+
+Hoe.new('serial_interface', SerialInterface::VERSION) do |p|
+  p.rubyforge_name = 'serial_interface'
+  p.summary = "abstracts protocols on a serial link"
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.url = "http://levinalex.net/src/serial_interface"
+  p.developer('Levin Alexander', 'mail@levinalex.net')
+
+  p.extra_deps = ["traits"]
+end
+
+task :cultivate do
+  system "touch Manifest.txt; rake check_manifest | grep -v \"(in \" | patch"
+  system "rake debug_gem | grep -v \"(in \" > `basename \\`pwd\\``.gemspec"
+end

data/lib/protocol/rca2006.rb

@@ -0,0 +1,197 @@
+module SerialProtocol
+
+  # Serial protocol Roboterclub Aachen 2006
+  # http://www.roboterclub.rwth-aachen.de/
+  #
+  # Packet format:
+  #   [0x65, 0xEB, <type:8>, <counter:8>, <length:8>, data:length>, <crc:16>]
+  #
+  # <type> is one of the following:
+  #    0b00000000 --> Data packet, discard on checksum mismatch
+  #    0b00011111 --> Data packet, resend on checksum mismatch
+  #    0b11100011 --> ACK packet
+  #    0b11111100 --> NACK packet
+  #
+  class RCA2006
+  
+    STARTBYTES = "\x65\xeb"
+    TYPE = {
+      :data_no_crc => 0, 
+      :data        => 0b00011111, 
+      :ack         => 0b11100011, 
+      :nack        => 0b11111100 }
+
+    def initialize(send_callback, receive_callback, options = {})
+      @rec_queue = Queue.new
+      @state = :first_startbyte
+      @send_callback = send_callback
+      @receive_callback = receive_callback
+    end
+
+    # Set callbacks whenever a packet is sent or received.
+    #
+    def on_raw_receive(&block)
+      @raw_receive_callback = block
+    end
+    def on_raw_send(&block)
+      @raw_send_callback = block
+    end
+    
+    # Wrap a string into a packet
+    #
+    # the options-hash can be used to override the default packet format
+    #
+    def send_packet(data, options = {})
+      str = data.to_s
+      type = TYPE[ options[:type] || :data_no_crc].chr
+      counter = options[:counter] || 0
+      checksum = options[:checksum] || ("" << counter << str.length << str).crc_xmodem
+
+      @raw_send_callback.call(type, counter, data, checksum) if @raw_send_callback
+      
+      p = "" << STARTBYTES << type << counter << str.length << str << [checksum].pack("S").reverse
+
+      # send the packet, using the callback
+      #
+      @send_callback.call(p)
+    end
+
+    def receive_handler(type, counter, data, checksum)
+      @raw_receive_callback.call(type,counter,data,checksum) if @raw_receive_callback
+      
+      case type
+      when :ack
+      when :nack
+      when :data
+        @receive_callback.call(data)
+      when :data_no_crc
+        @receive_callback.call(data)
+      end
+    end
+
+    # Big and ugly state machine that does most of the work
+    # 
+    def add_char_to_packet(char)
+      @state = :first_checksum if (@state == 0)
+      case @state
+      when :first_startbyte
+        @data = ""
+        @state = ((char == STARTBYTES[0]) ? :second_startbyte : :first_startbyte)
+      when :second_startbyte
+        @state = (char == STARTBYTES[1]) ? :type : 
+          # special case: first startbyte is repeated
+          (char == STARTBYTES[0] ? :second_startbyte : :first_startbyte)
+      when :type
+        @type = TYPE.invert[char]
+        @state = :counter
+      when :counter
+        @counter = char
+        @state = :length
+      when :length
+        @length = char
+        @state = @length
+      when Integer
+        @data << char
+        @state -= 1
+      when :first_checksum
+        @checksum = (char << 8)
+        @state = :second_checksum
+      when :second_checksum
+        @checksum = @checksum + char
+        @state = :first_startbyte
+
+        crc = ("" << @counter << @length << @data).crc_xmodem
+          # received a valid packet
+          
+        if @type == :data || @type == :data_no_crc
+          if @checksum == crc
+             
+            # send ACK
+            send_packet(nil, :type => :ack, :counter => @counter)
+            receive_handler(@type, @counter, @data,@checksum)
+          else
+            # send NACK and discard packet
+            send_packet(nil, :type => :nack, :counter => @counter)
+            raise ChecksumMismatch, "ChecksumMismatch, expected #{crc}, was #{@checksum}"
+          end
+        else
+          # the packet is ACK, NACK or unknown, call receive-handler
+          # data may be mangled since the checksum is not checked
+          #
+          receive_handler(@type, @counter, @data, @checksum)
+        end
+      end        
+    end
+  end
+
+  class RCA2006Simple < RCA2006
+    def initialize(send_callback, receive_callback, options = {})
+      @type = :data_no_crc
+      @counter = 0
+      super
+    end
+
+    # Wrap a string into a packet
+    #
+    # the options-hash can be used to override the default packet format
+    #
+    def send_packet(data, options = {})
+      str = data.to_s
+      checksum = options[:checksum] || ("" << str.length << str).crc_xmodem
+
+      @raw_send_callback.call(:data_no_crc, 0, data, checksum) if @raw_send_callback
+      
+      p = "" << STARTBYTES << str.length << str << [checksum].pack("S").reverse
+
+      # send the packet, using the callback
+      #
+      @send_callback.call(p)
+    end
+    
+    # Big and ugly state machine that does most of the work
+    # 
+    def add_char_to_packet(char)
+      @state = :first_checksum if (@state == 0)
+      case @state
+      when :first_startbyte
+        @data = ""
+        @state = ((char == STARTBYTES[0]) ? :second_startbyte : :first_startbyte)
+      when :second_startbyte
+        @state = (char == STARTBYTES[1]) ? :length : 
+          # special case: first startbyte is repeated
+          (char == STARTBYTES[0] ? :second_startbyte : :first_startbyte)
+      when :length
+        @length = char
+        @state = @length
+      when Integer
+        @data << char
+        @state -= 1
+      when :first_checksum
+        @checksum = (char << 8)
+        @state = :second_checksum
+      when :second_checksum
+        @checksum = @checksum + char
+        @state = :first_startbyte
+
+        crc = ("" << @length << @data).crc_xmodem
+          # received a valid packet
+          
+        if @type == :data || @type == :data_no_crc
+          if @checksum == crc
+             
+            receive_handler(@type, @counter, @data,@checksum)
+          else
+            # send NACK and discard packet
+            raise ChecksumMismatch, "ChecksumMismatch, expected #{crc}, was #{@checksum}"
+          end
+        else
+          # the packet is ACK, NACK or unknown, call receive-handler
+          # data may be mangled since the checksum is not checked
+          #
+          receive_handler(@type, @counter, @data, @checksum)
+        end
+      end        
+    end
+  end
+end
+

data/lib/serial_interface.rb

@@ -0,0 +1,224 @@
+#!usr/bin/ruby -w
+
+require 'thread'
+require 'enumerator'
+require 'timeout'
+
+require File.join(File.dirname(__FILE__),'serial_packet.rb')
+
+# FIXME: this should probably be put in a separate file
+#
+class String
+  def crc_xmodem
+    self.to_enum(:each_byte).inject(0) { |crc,byte|
+      crc = (crc ^ (byte << 8)) % 0x10000
+      8.times { 
+        crc <<= 1
+        crc ^= 0x1021 if crc[16] == 1
+      }
+      crc
+    } % 0x10000
+  end
+end
+
+module SerialInterface
+  VERSION = '0.2.3'
+end
+
+# PacketIO is used to wrap data in packets and send them
+# over a serial port or some other IO
+# 
+class PacketIO
+  attr_accessor :protocol_handler
+    
+  # Takes two IO-Objects (uses "readchar" and "<<") to read and write from
+  #
+  def initialize(protocol, read, write = read, options = {})
+    @read, @write = read, write
+    @on_receive = nil
+    
+    # Hashes contain SerialPackets that can be sent and received
+    # 
+    @sendable_packets = {}
+    @receivable_packets = []
+
+    @waiting_threads = []
+
+    @protocol_handler = protocol.new(method(:send_callback),method(:receive_callback), options)
+
+    # Create the receiver thread, but do not start it yet
+    #
+    @receiver_thread = Thread.new do 
+      Thread.abort_on_exception = true
+      Thread.stop
+      
+      loop do
+        begin
+          char = @read.readchar
+          @protocol_handler.add_char_to_packet(char) if char
+        rescue EOFError
+          Thread.pass # there is currently nothing to read  
+        end
+      end if @read  # no need to loop, if there is nothing to read from
+    end
+  end
+
+  # suspends the current thread, until +num+ packets have been received
+  # the thread will be resumed after all callbacks were called 
+  #
+  def wait_for_packet(num_packets = 1, timeout = 10)
+    begin
+      @waiting_threads << {:num => num_packets, :thread => Thread.current}
+      sleep timeout
+      raise Timeout::Error, "Timeout"
+    rescue SerialProtocol::PacketReceived => e
+    ensure
+      # delete all occurrences of the current thread from the list of waiting threads,
+      # as we are obviously not waiting anymore
+      @waiting_threads.delete_if { |h| h[:thread] == Thread.current }
+    end
+  end
+
+  # The block given to this method is called with every received string
+  #
+  def on_receive(&block)
+    @on_receive = block
+  end
+
+  def add_sender(hash = {})
+    hash.each { |k,v|
+      @sendable_packets[k] = v
+    }
+    self
+  end
+
+  # Add a type of packet, that should be checked for in the interface
+  # 
+  # If a packet is received
+  #
+  def add_receiver(hash = {}, &block)
+    hash.each { |k,v|
+      @receivable_packets << {:packet => v, :block => block}
+    }
+    self
+  end
+  
+  # Data to be wrapped in a packet
+  #
+  # there are different ways of using this method:
+  #
+  # send_packet(sym, *data)
+  # send_packet(sym, options = {}, *data)
+  #   looks for a packet-class named sym and creates a new instance of this type
+  #   of packet
+  #   the optional hash is passed to the protocol layer
+  #
+  # send_packet(string, options = {})
+  #   sends a raw string
+  #   the optional hash is passed to the protocol layer
+  #
+  #
+  def send_packet(data, *args)
+    options = (Hash === args.first) ? options = args.shift : {}
+    data = (Symbol === data) ? @sendable_packets[data].new(*args) : data
+    
+    @protocol_handler.send_packet(data.to_str, options)
+    self
+  end
+
+  # starts the receiver thread
+  #
+  def run
+    @receiver_thread.wakeup
+    self
+  end
+
+  def join
+    @receiver_thread.join
+    self
+  end
+  
+  private
+  
+  # this method is called, when a packet should be sent
+  #
+  def send_callback(str)
+    @write << str if @write
+  end
+
+  def receive_callback(packet_str)
+    # call the on_receive event handler for every packet
+    @on_receive.call(packet_str) if @on_receive
+
+    # try to match the packet-string against the list of known packets
+    @receivable_packets.each { |h|
+      if h[:packet].matches?(packet_str)
+        h[:block].call( h[:packet].from_str(packet_str) )
+      end
+    }
+    
+    # check if there are threads to wake up
+    #
+    @waiting_threads.each { |h|
+      h[:num] -= 1 # decrease the number of packets, this thread waits for
+      h[:thread].raise SerialProtocol::PacketReceived if h[:num] == 0
+    }
+  end
+
+end
+
+module SerialProtocol
+  class ChecksumMismatch < RuntimeError
+  end
+  
+  class PacketReceived < Exception
+  end
+end
+
+module SerialProtocol
+
+  # The classes in this section implement wrappers for specific protocols
+  # to be used on a serial port
+  # 
+  # They need to implement the following methods:
+  #
+  #  initialize(send_callback, receive_callback, option_hash = {})
+  #    creates a new instance of the protocol object
+  #    it gets two methods to talk back to the interface
+  #    class
+  #
+  #  add_char_to_packet(char)
+  #    called for each char, that is received.
+  #  
+  #  send_packet(data, options)
+  #    called from the application to send a packet.  The class is
+  #    expected to wrap the data in the specific packet format string and in 
+  #    turn call send_callback(data_str) which will take care of the actual
+  #    transmission
+  # 
+  # A protocol class is expected to call receive_callback(packet_str) as soon
+  # as a valid packet is received
+  # 
+
+
+  class LineBased
+    def initialize(send_callback, receive_callback, options = {})
+      @send_callback, @receive_callback = send_callback, receive_callback
+      @packet_buffer = ""
+    end
+
+    def add_char_to_packet(char)
+      if /\n/ === char.chr
+        @receive_callback.call(@receive_buffer)        
+        @packet_buffer = ""
+      else
+        @packet_buffer << char
+      end
+    end
+
+    def send_packet(data, options = {})
+      @send_callback.call(data + "\n")
+    end
+  end
+end
+

data/lib/serial_packet.rb

@@ -0,0 +1,116 @@
+#!usr/bin/ruby
+
+require 'rubygems'
+gem 'traits', "0.8.1"
+require 'traits' # from http://www.codeforpeople.com/lib/ruby/traits/traits-0.8.1/
+
+# SerialPacket is used to define the format of Packets that
+# can be sent and received over a serial link
+#
+# they are essentially a description how to create a string
+# representation from an array
+#
+# a packet has the following properties:
+#
+#   data_format(string)
+#      this is a string that is passed to 'pack' and 'unpack'
+#
+#   header_format(string)   
+#      this is the format of the header of received packets
+#      this property is used with SerialPacket.matches?
+#
+#   header_data
+#      an array that is used to decide if a given String is
+#      
+module SerialPacketModule
+  def self.included(other)
+    other.class_eval do 
+
+      def initialize_from_packet(str)
+        self.data = str.unpack(self.class.data_format)      
+      end
+      
+      def initialize(*d)
+        self.data = d
+      end
+
+      def to_str
+        self.class.header_str << self.data.pack(self.class.data_format)
+      end
+      
+      class << self
+
+        # a packet can only be sent if it has a header
+        #
+        def sendable?
+          (self.header && self.header_format) ? true : false
+        end
+
+        def header_str
+          if sendable?
+            h = self.header || []
+            h.pack(self.header_format) || ""
+          else
+            ""
+          end
+        end
+        
+        # a packet can only be received, if it has a filter-expression
+        def receiveable?
+          defined? header_format and header_filter
+        end
+
+        # checks if some string conforms to the format of this packet
+        #
+        # this is tested by matching the packet "header" against the 
+        # provided filter-expression
+        #
+        def matches?(str)
+          header = str.unpack(header_format)
+          filter = self.header_filter || []
+          filter.zip(header) { |f,a| return false unless f === a }
+          return true
+        end
+
+        def from_str(str) #:nodoc:
+          p = self.allocate
+          p.initialize_from_packet(str)
+          p
+        end
+
+        def create(&block)
+          klass = Class.new(self)
+          klass.instance_eval(&block) if block
+          return klass    
+        end
+      end
+    end
+  end
+end
+
+class SerialPacket
+  include SerialPacketModule
+
+  class_trait :data_format => "C*"   # packet defaults to an array of bytes
+  class_trait :header_format => "CC" # it has a 2-byte header
+  class_trait :header_filter => ""   # it will react to every byte
+  class_trait :header => nil # there is no default header
+                             # this should be "[]" but arrays do not work
+                             # in traits
+  traits :data => nil
+
+  # to store custom data in the packat, override
+  # one or more of the following methods:
+  #
+  # initialize_from_packet(str)
+  #   populate instance variables with data
+  #
+  # to_str
+  #   return the string that is sent over the wire
+  #
+  # matches?(str)
+  #   default implementation uses +header_format+ and +header+
+  #   to determine if a given string matches a packet
+
+end
+

data/serial_interface.gemspec

@@ -0,0 +1,36 @@
+Gem::Specification.new do |s|
+  s.name = %q{serial_interface}
+  s.version = "0.2.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Levin Alexander"]
+  s.date = %q{2008-10-12}
+  s.description = %q{serial_interface intends to be a small library that makes it easy to define packet based protocols over a serial link (RS232) in a declarative fashion.}
+  s.email = ["mail@levinalex.net"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
+  s.files = ["History.txt", "Manifest.txt", "README.txt", "Rakefile", "lib/protocol/rca2006.rb", "lib/serial_interface.rb", "lib/serial_packet.rb", "serial_interface.gemspec", "test/test_serial_interface.rb", "test/test_serial_io.rb", "test/test_serial_packets.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://levinalex.net/src/serial_interface}
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{serial_interface}
+  s.rubygems_version = %q{1.2.0}
+  s.summary = %q{abstracts protocols on a serial link}
+  s.test_files = ["test/test_serial_interface.rb", "test/test_serial_io.rb", "test/test_serial_packets.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if current_version >= 3 then
+      s.add_runtime_dependency(%q<traits>, [">= 0"])
+      s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
+    else
+      s.add_dependency(%q<traits>, [">= 0"])
+      s.add_dependency(%q<hoe>, [">= 1.8.0"])
+    end
+  else
+    s.add_dependency(%q<traits>, [">= 0"])
+    s.add_dependency(%q<hoe>, [">= 1.8.0"])
+  end
+end

data/test/test_serial_interface.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/ruby -w
+
+require 'test/unit'
+require 'stringio'
+require 'serial_interface'
+require 'protocol/rca2006'
+
+class TestSerialInterface < Test::Unit::TestCase
+  def setup
+
+    @data_packet = SerialPacket.create { data_format "C*"; header [?:,?D] }
+    
+    @io_send = StringIO.new
+    @io_receive = StringIO.new
+    
+    @sender = PacketIO.new(SerialProtocol::RCA2006, nil, @io_send)
+    @receiver = PacketIO.new(SerialProtocol::RCA2006, @io_receive, nil)
+  end
+  
+  def test_send_packet
+    @sender.add_sender(:data => @data_packet).run
+
+    @sender.send_packet :data, ?A, ?B, ?C, ?D, ?E
+    @io_send.rewind
+    
+    assert_equal("\x65\xEB\x00\x00\a:DABCDE\2443",@io_send.read)
+  end
+
+  def test_receive_packet
+    @io_receive << "\x65\xEB\x00\x00\a:DABCDE\2443"
+    @io_receive.rewind
+
+    @receiver.add_receiver(:data => @data_packet) do |packet|
+      assert_equal( [?:,?D,?A,?B,?C,?D,?E], packet.data )
+    end
+    @receiver.run
+  end
+
+  def test_timeout
+    @receiver.on_receive { |str| @data = str }
+    @receiver.run
+    
+    Thread.new {
+      Thread.pass
+      @io_receive << "\x65\xEB\x00\x00\a:DABCDE\2443"
+      @io_receive.rewind
+    }
+
+    assert_equal( nil, @data )
+    assert_nothing_raised {
+      @receiver.wait_for_packet(1,2)
+    }
+    assert_equal( ":DABCDE", @data )
+
+    assert_raises(Timeout::Error) {
+      @receiver.wait_for_packet(1,1)
+    }
+  end
+
+
+end
+
+

data/test/test_serial_io.rb

@@ -0,0 +1,7 @@
+require 'test/unit'
+
+class TestSerialIO < Test::Unit::TestCase
+  def test_success
+    
+  end
+end

data/test/test_serial_packets.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/ruby -w
+
+require 'test/unit'
+require 'tempfile'
+
+require 'serial_packet'
+
+class TestPacketFilter < Test::Unit::TestCase
+  def setup
+    @default_packet_format = SerialPacket.create
+    @default_packet = @default_packet_format.new
+  end
+
+  def test_instantiate_empty_packet
+    assert_equal([], @default_packet.data)
+    assert_equal("", @default_packet.to_str)
+  end
+  
+  def test_instantiate_basic_packet
+    p = @default_packet_format.new ?A,?B,?C
+
+    assert_equal([?A,?B,?C], p.data)
+    assert_equal("ABC", p.to_str)
+  end
+
+  def test_packet_format_string
+    my_packet = SerialPacket.create { data_format "A*" }
+    p = my_packet.new "Hallo"
+
+    assert_equal(["Hallo"], p.data)
+    assert_equal("Hallo", p.to_str)
+  end  
+
+  def test_packet_create_from_str
+    p = @default_packet_format.from_str("bar")
+
+    assert_equal([?b,?a,?r], p.data)
+  end
+  
+  def test_packet_header
+    my_packet = SerialPacket.create { header_format "CC"; header [?a,?b] }
+    
+    assert_equal([?a,?b], my_packet.header)  
+  end
+
+  def test_match
+    empty = SerialPacket.create
+    numbers = SerialPacket.create { header_format "ss"; header_filter [-1,32767] }
+    regex = SerialPacket.create{ header_format "a*"; header_filter [/foo/] }
+    mixed = SerialPacket.create { header_format "@5C @2C"; header_filter [?X,?Y] }
+    
+    assert_equal true, empty.matches?("abcde")
+    
+    assert_equal(true, numbers.matches?("\xff\xff\xff\x7f"))
+    assert_equal(false, numbers.matches?("\xff\xff\xff\x80"))        
+    assert_equal(false, numbers.matches?("Packet with foo in it")) 
+    assert_equal(true, regex.matches?("Packet with foo in it")) 
+    assert_equal(false, regex.matches?("Packet with bar in it"))    
+    assert_equal(false, regex.matches?("\xff\xff\xff\x80"))        
+    assert_equal true, mixed.matches?("__Y__X___")
+    assert_equal false, mixed.matches?("YYYYYYY")
+  end
+  
+  class Position < SerialPacket
+      header_format "CC"
+      header [?P,?p]
+      data_format "SS"
+  end
+
+  def test_position_packet
+    p = Position.new 1, -1
+    assert_equal("Pp\001\000\xff\xff", p.to_str)
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: levinalex-serial_interface
+version: !ruby/object:Gem::Version 
+  version: 0.2.3
+platform: ruby
+authors: 
+- Levin Alexander
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-12 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: traits
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: serial_interface intends to be a small library that makes it easy to define packet based protocols over a serial link (RS232) in a declarative fashion.
+email: 
+- mail@levinalex.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/protocol/rca2006.rb
+- lib/serial_interface.rb
+- lib/serial_packet.rb
+- serial_interface.gemspec
+- test/test_serial_interface.rb
+- test/test_serial_io.rb
+- test/test_serial_packets.rb
+has_rdoc: true
+homepage: http://levinalex.net/src/serial_interface
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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: serial_interface
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: abstracts protocols on a serial link
+test_files: 
+- test/test_serial_interface.rb
+- test/test_serial_io.rb
+- test/test_serial_packets.rb