katcp 0.0.2

data/README

@@ -0,0 +1,110 @@
+--
+
+ This file includes an RDoc hack so that links can be made to open up into a
+ new frame rather then the current frame.
+ 
+ The "trick" is to append ``"target="_top'' to the URL.
+
+++
+
+= Ruby/KATCP
+
+== Introduction
+
+<b>Ruby/KATCP</b> is a Ruby extension for communicating via the Karoo Array
+Telescope Control Protocol (KATCP).  More information about KATCP can be
+found at the {CASPER
+Wiki}[http://casper.berkeley.edu/wiki/KATCP"target="_top], including the {KATCP
+specification
+}[http://casper.berkeley.edu/wiki/images/1/11/NRF-KAT7-6.0-IFCE-002-Rev4.pdf"target="_top]
+in PDF format.
+
+== Features
+
+* Provides a base KATCP client supporting the functionality described in the
+  KATCP specification.
+
+* Provides an extended KATCP client to support the <tt>tcpborphserver2</tt>
+  KATCP server implementation on {ROACH
+  }[http://casper.berkeley.edu/wiki/ROACH"target="_top] boards.
+
+* Automatically provides support for all current and any future KATCP request
+  types through the use of Ruby's +method_missing+ feature.
+
+* Handles all escaping and unescaping of text transferred over KATCP.
+
+* Provides convenient and flexible ways of converting packed binary data to
+  various numerical formats, including Array and {NArray
+  }[http://narray.rubyforge.org/"target="_top] objects.
+
+* Plays nicely with +irb+, the interactive Ruby shell.
+
+== Installation
+
+{Ruby/KATCP}[http://rb-katcp.rubyforge.org/"target="_top] can be installed
+via RubyGems[http://www.rubygems.org/"target="_top]:
+
+  gem install katcp
+
+Ruby/KAT<b></b>CP was developed using Ruby 1.8.6 and 1.8.7.  It has not been
+tested against Ruby 1.9 (yet).
+
+== Documentation
+
+Documentation is available on the {Ruby/KATCP
+Homepage}[http://rb-katcp.rubyforge.org/"target="_top] and is also installed
+locally as part of the gem-based installation.  To view the documentation
+locally, run
+
+  gem server
+
+then point your browser to <tt>http</tt><tt>://localhost:8808/</tt> and
+navigate to (and follow) the katcp <b>[rdoc]</b> link.  You can get more
+information about RubyGem's documenation server by running:
+
+  gem help server
+
+== Example
+
+This example script, <tt>listdev.rb</tt>, can be used to list the devices on a
+given ROACH host...
+
+  #!/usr/bin/env ruby
+  
+  # listdev.rb - list devices on a ROACH
+  #
+  #   $ listdev.rb roach030111
+  #   XAUI0
+  #   acc_len
+  #   ant_levels
+  #   ctrl
+  #   gbe0
+  #   gbe_ip0
+  #   gbe_port
+  #   [...]
+  
+  require 'rubygems'
+  require 'katcp'
+  
+  # Abort if no hostname is given
+  raise "\nusage: #{$0} HOSTNAME" unless ARGV[0]
+  
+  # Create RoachClient object
+  roach = KATCP::RoachClient.new(ARGV[0])
+  
+  # Get list of devices via "?listdev" KATCP request.
+  # Save returned KATCP::Response object in "resp".
+  resp = roach.listdev
+  
+  # Extract first "word" of each line except the last
+  # one, which will be a "!listdev ok" reply line.
+  devices = resp.lines[0..-2].map {|l| l[1]}
+  
+  # Output device list
+  puts devices
+
+== Current Limitations
+
+* Only the client side is implemented.
+* Only TCP communication is supported (i.e. no RS/232 support).
+* KATCP::RoachClient#uploadbof is not yet implemented.

data/examples/listdev.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+# listdev.rb - list devices on a ROACH
+#
+#   $ listdev.rb roach030111
+#   XAUI0
+#   acc_len
+#   ant_levels
+#   ctrl
+#   gbe0
+#   gbe_ip0
+#   gbe_port
+#   [...]
+
+require 'rubygems'
+require 'katcp'
+
+# Abort if no hostname is given
+raise "\nusage: #{$0} HOSTNAME" unless ARGV[0]
+
+# Create RoachClient object
+roach = KATCP::RoachClient.new(ARGV[0])
+
+# Get list of devices via "?listdev" KATCP request.
+# Save returned KATCP::Response object in "resp".
+resp = roach.listdev
+
+# Extract first "word" of each line except the last
+# one, which will be a "!listdev ok" reply line.
+devices = resp.lines[0..-2].map {|l| l[1]}
+
+# Output device list
+puts devices

data/lib/katcp/client/roach.rb

@@ -0,0 +1,141 @@
+require 'katcp/client'
+
+# Holds KATCP related classes etc.
+module KATCP
+
+  # Facilitates talking to <tt>tcpborphserver2</tt>, a KATCP server
+  # implementation that runs on ROACH boards.  Mostly just adds convenience
+  # methods for tab completion in irb.
+  #
+  #   TODO: Add conveneince methods for converting binary payload data.
+  class RoachClient < Client
+
+    # call-seq:
+    #  delbof(image_file) -> KATCP::Response
+    #
+    # Deletes gateware image file named by +image_file+.
+    def delbof(image_file)
+      request(:delbof, image_file)
+    end
+
+    # call-seq:
+    # echotest(ip_address, echo_port, byte_count) -> KATCP::Response
+    #
+    # Basic network echo tester.
+    def echotest(ip_address, echo_port, byte_count)
+      request(:echotest, ip_address, echo_port, byte_count)
+    end
+
+    # call-seq:
+    #  listbof -> KATCP::Response
+    #
+    # Lists available gateware images.
+    def listbof
+      request(:listbof).sort!
+    end
+
+    # call-seq:
+    #  listdev -> KATCP::Response
+    #
+    # Lists available registers.
+    def listdev
+      request(:listdev, :size).sort!
+    end
+
+    # call-seq:
+    #   progdev -> KATCP::Response
+    #   progdev(image_file) -> KATCP::Response
+    #
+    # Programs a gateware image specified by +image_file+.  If +image_file+ is
+    # omitted, de-programs the FPGA.
+    def progdev(*args)
+      request(:progdev, *args)
+    end
+
+    # call-seq:
+    #   read(register_name) -> KATCP::Response
+    #   read(register_name, register_offset) -> KATCP::Response
+    #   read(register_name, register_offset, byte_count) -> KATCP::Response
+    #
+    # Reads a +byte_count+ bytes starting at +register_offset+ offset from
+    # register (or block RAM) named by +register_name+.  Binary data can be
+    # obtained from the Response via the Response#payload method.
+    def read(register_name, *args)
+      request(:read, register_name, *args)
+    end
+
+    # call-seq:
+    #  status -> KATCP::Response
+    #
+    # Reports if gateware has been programmed.
+    def status
+      request(:status)
+    end
+
+    # call-seq:
+    #  sysinit -> KATCP::Response
+    #
+    # Writes the timing ctl register that resets the entire system.
+    #
+    # [Presumably this depends on a certain register naming convention?]
+    def sysinit
+      request(:sysinit)
+    end
+
+    # call-seq:
+    #   tap_start(tap_device register_name, ip_address) -> KATCP::Response
+    #   tap_start(tap_device register_name, ip_address, port) -> KATCP::Response
+    #   tap_start(tap_device register_name, ip_address, port, mac) -> KATCP::Response
+    #
+    # Start a tgtap instance.
+    def tap_start(tap_device, register_name, ip_address, *args)
+      request(:tap_start, tap_device, register_name, ip_address, *args)
+    end
+
+    # call-seq:
+    #  tap_stop(register_name) -> KATCP::Response
+    #
+    # Stop a tgtap instance.
+    def tap_stop(register_name)
+      reqest(:tap_stop, register_name)
+    end
+
+    # call-seq:
+    #   uploadbof(net_port, filename) -> KATCP::Response
+    #   uploadbof(net_port, filename, size) -> KATCP::Response
+    #
+    # Upload a gateware image.
+    #
+    #   NOT YET IMPLEMENTED
+    def uploadbof(net_port, filename, *args)
+      raise NotImplementedError.new('uploadbof not yet implemented')
+    end
+
+    # call-seq:
+    #   wordread(register_name) -> KATCP::Response
+    #   wordread(register_name, word_offset) -> KATCP::Response
+    #   wordread(register_name, word_offset, length) -> KATCP::Response
+    #
+    # Reads word(s) from +register_name+.
+    def wordread(register_name, *args)
+      request(:wordread, register_name, *args)
+    end
+
+    # call-seq:
+    #   wordwrite(register_name, word_offset, payload[, ...]) -> KATCP::Response
+    #
+    # Writes one or more words to a register (or block RAM).
+    def wordwrite(register_name, word_offset, *args)
+      request(:wordwrite, register_name, word_offset, *args)
+    end
+
+    # call-seq:
+    # write(register_name, register_offset, data_payload) -> KATCP::Response
+    #
+    # Write a given payload to an offset in a register.
+    def write(register_name, register_offset, data_payload)
+      request(:write, register_name, register_offset, data_payload)
+    end
+
+  end # class RoachClient
+end # module KATCP

data/lib/katcp/client.rb

@@ -0,0 +1,258 @@
+require 'monitor'
+require 'socket'
+
+require 'katcp/response'
+require 'katcp/util'
+
+# Holds KATCP related classes etc.
+module KATCP
+
+  # Facilitates talking to a KATCP server.
+  class Client
+
+    # Creates a KATCP client that connects to a KATCP server at +remote_host+
+    # on +remote_port+.  If +local_host+ and +local_port+ are specified, then
+    # those parameters are used on the local end to establish the connection.
+    def initialize(remote_host, remote_port=7147, local_host=nil, local_port=nil)
+
+      # Save remote_host and remote_port for #inspect
+      @remote_host = remote_host
+      @remote_port = remote_port
+
+      # @socket is the socket connecting to the KATCP server
+      @socket = TCPSocket.new(remote_host, remote_port, local_host, local_port)
+
+      # Init attribute(s)
+      @informs = []
+
+      # @reqlock is the Monitor object used to serialize requests sent to the
+      # KATCP server.  Threads should not write to @socket or read from @rxq
+      # or change @reqname unless they have acquired (i.e. synchonized on)
+      # @reqlock.
+      @reqlock = Monitor.new
+
+      # @reqname is the request name currently being processed (nil if no
+      # current request).
+      @reqname = nil
+
+      # @rxq is an inter-thread queue
+      @rxq = Queue.new
+
+      # Start thread that reads data from server.
+      Thread.new do
+        # TODO: Monkey-patch gets so that it recognizes "\r" or "\n" as line
+        # endings.  Currently only recognizes fixed strings, so for now go with
+        # "\n".
+        while line = @socket.gets("\n") do
+          # Split line into words and unescape each word
+          words = line.split.map! {|w| w.katcp_unescape!}
+          # Handle requests, replies, and informs based on first character of
+          # first word.
+          case words[0][0,1]
+          # Request
+          when '?'
+            # TODO Send 'unsupported' reply (or support requests from server?)
+          # Reply
+          when '!'
+            # TODO: Raise exception if name is not same as @reqname?
+            # TODO: Raise exception on non-ok?
+            # Enqueue words to @rxq
+            @rxq.enq(words)
+          # Inform
+          when '#'
+            # If the name is same as @reqname
+            if @reqname && @reqname == words[0][1..-1]
+              # Enqueue words to @rxq
+              @rxq.enq(words)
+            else
+              # Must be asynchronous inform message, add to list.
+              line.katcp_unescape!
+              line.chomp!
+              @informs << line
+            end
+          else
+            # Malformed line
+            # TODO: Log error better?
+            warn "malformed line: #{line.inspect}"
+          end
+
+        end # @socket.each_line block
+
+        warn "Read on socket returned EOF"
+        #TODO Close socket?  Push EOF flag into @rxq?
+      end # Thread.new block
+    end
+
+    # TODO: Have a log_handler?
+
+    # call-seq:
+    #   request(name, *arguments) -> KATCP::Response
+    #
+    # Sends request +name+ with +arguments+ to server.  Returns KATCP::Response
+    # object.
+    #
+    #   TODO: Raise exception if reply is not OK?
+    def request(name, *arguments)
+      # Massage name to allow Symbols and to allow '_' between words (since
+      # that is more natural for Symbols) in place of '-'
+      name = name.to_s.gsub('_','-')
+
+      # Escape arguments
+      arguments.map! {|arg| arg.to_s.katcp_escape}
+
+      # Create response
+      resp = Response.new
+
+      # Get lock on @reqlock
+      @reqlock.synchronize do
+        # Store request name
+        @reqname = name
+        # Send request
+        req = "?#{[name, *arguments].join(' ')}\n"
+        @socket.print req
+        # Loop on reply queue until done or error
+        begin
+          words = @rxq.deq
+          resp << words
+        end until words[0][0,1] == '!'
+        # Clear request name
+        @reqname = nil
+      end
+      resp
+    end
+
+    # call-seq:
+    #   inform(clear=false) -> Array
+    #
+    # Returns Array of inform messages.  If +clear+ is +true+, clear messages.
+    def informs(clear=false)
+      msgs = @informs
+      @informs = [] if clear
+      msgs
+    end
+
+    # Translates calls to missing methods into KATCP requests.
+    def method_missing(sym, *args)
+      request(sym, *args)
+    end
+
+    # Provides terse string representation of +self+.
+    def to_s
+      s = "#{@remote_host}:#{@remote_port}"
+    end
+
+    # Provides more detailed String representation of +self+
+    def inspect
+      "#<#{self.class.name} #{to_s} (#{@informs.length} inform messages)>"
+    end
+
+    # call-seq:
+    #   client_list -> KATCP::Response
+    #
+    # Issues a client_list request to the server.
+    def client_list
+      request(:client_list)
+    end
+
+    # call-seq:
+    #   configure(*args) -> KATCP::Response
+    #
+    # Issues a configure request to the server.
+    def configure(*args)
+      request(:configure, *args)
+    end
+
+    # call-seq:
+    #   halt -> KATCP::Response
+    #
+    # Issues a halt request to the server.  Shuts down the system.
+    def halt
+      request(:halt)
+    end
+
+    # call-seq:
+    #   help -> KATCP::Response
+    #   help(name) -> KATCP::Response
+    #
+    # Issues a help request to the server.  If +name+ is a Symbol, all '_'
+    # characters are changed to '-'.  Response inform lines are sorted.
+    def help(*args)
+      # Change '_' to '-' in Symbol args
+      args.map! do |arg|
+        arg = arg.to_s.gsub('-', '_') if Symbol === arg
+        arg
+      end
+      request(:help, *args).sort!
+    end
+
+    # call-seq:
+    #   log_level -> KATCP::Response
+    #   log_level(priority) -> KATCP::Response
+    #
+    # Query or set the minimum reported log priority.
+    def log_level(*args)
+      request(:log_level, *args)
+    end
+
+    # call-seq:
+    #   mode -> KATCP::Response
+    #   mode(new_mode) -> KATCP::Response
+    #
+    # Query or set the current mode.
+    def mode(*args)
+      request(:mode, *args)
+    end
+
+    # call-seq:
+    #   restart -> KATCP::Response
+    #
+    # Issues a restart request to the server to restart the remote system.
+    def restart
+      request(:restart)
+    end
+
+    # call-seq:
+    #   sensor_dump(*args) -> KATCP::Response
+    #
+    # Dumps the sensor tree.
+    def sensor_dump(*args)
+      request(:sensor_dump, *args)
+    end
+
+    # call-seq:
+    #   sensor_list(*args) -> KATCP::Response
+    #
+    # Queries for list of available sensors.  Response inform lines are sorted.
+    def sensor_list(*args)
+      request(:sensor_list, *args).sort!
+    end
+
+    # call-seq:
+    #   sensor_sampling(sensor) -> KATCP::Response
+    #   sensor_sampling(sensor, strategy, *parameters) -> KATCP::Response
+    #
+    # Quesry or set sampling parameters for a sensor.
+    def sensor_sampling(sensor, *args)
+      request(:sensor_sampling, sensor, *args)
+    end
+
+    # call-seq:
+    #   sensor_value(sensor) -> KATCP::Response
+    #
+    # Query a sensor.
+    def sensor_value(sensor)
+      request(:sensor_value, sensor)
+    end
+
+    # call-seq:
+    #   watchdog -> KATCP::Response
+    #
+    # Issues a watchdog request to the server.
+    def watchdog
+      request(:watchdog)
+    end
+
+    alias :ping :watchdog
+
+  end # class Client
+end # module KATCP

data/lib/katcp/irb.rb

@@ -0,0 +1,3 @@
+# Facilitate running katcp in an IRB session
+require 'katcp'
+IRB.conf[:PROMPT_MODE] = :DEFAULT

data/lib/katcp/response.rb

@@ -0,0 +1,209 @@
+require 'katcp/util'
+require 'katcp/version'
+
+# Holds KATCP related classes etc.
+module KATCP
+
+  # Class that holds response to request.  Bascially like an Array with each
+  # element representing a line of the server's response.  Each "line" is
+  # stored as an Array (of Strings) whose elements are the unescaped "words"
+  # (which may contain embedded spaces) of the reply.
+  class Response
+
+    # Default inspect_mode for new Response objects.  When running in IRB,
+    # default is :to_s, otherwise, default is nil.
+    @@inspect_mode = (defined?(IRB) ? :to_s : nil)
+
+    # Returns default inspect mode for new Response objects.
+    def self.inspect_mode
+      @@inspect_mode
+    end
+
+    # Sets default inspect mode for new Response objects.
+    def self.inspect_mode=(mode)
+      @@inspect_mode = mode
+    end
+
+    # Inspect mode for +self+. +nil+ or <tt>:inspect</tt> means terse form.
+    # Other symbol (typically <tt>:to_s</tt>) means call that method
+    attr :inspect_mode
+
+    # Creates a new Response object with given inspect_mode and lines Array
+    def initialize(inspect_mode=@@inspect_mode, lines_array=[])
+      raise TypeError.new('lines must be an Array') unless Array === lines_array
+      @lines = lines_array
+      @inspect_mode = inspect_mode
+    end
+
+    # call-seq:
+    #   lines -> Array of Arrays
+    #
+    # Returns a copy contained lines.  Each line is itself an Array of words.
+    def lines
+      @lines.map {|words| words.map {|word| word.dup}}
+    end
+
+    # call-seq:
+    #   grep(pattern, join=' ') -> Array or Strings
+    #   grep(pattern, nil) -> Array of Arrays
+    #   grep(pattern, join=' ') {|line_array| ...}-> Array of Strings
+    #   grep(pattern, nil) {|line_array| ...}-> Array of ...
+    #
+    # Greps through lines for +pattern+.  If a block is given, each line will
+    # be passed to the block and replaced in the returned Array by the block's
+    # return value.  If +join+ is non-nil (default is a space character), then
+    # each element of the returned Array (i.e. each line) will have its
+    # elements (i.e. words) joined together using +join+ as a delimiter.
+    def grep(pattern, join=' ', &block)
+      matches = @lines.find_all {|l| !l.grep(pattern).empty?}
+      matches.map!(&block) if block_given?
+      matches.map! {|l| l.join(join)} if join
+      matches
+    end
+
+    # call-seq:
+    #   dup -> KATCP::Response
+    #
+    # Returns a deep copy of self
+    def dup
+      self.class.new(@inspect_mode, lines)
+    end
+
+    # Pushes +line+ onto +self+.  +line+ must be an Array of words (each of
+    # which may contain embedded spaces).
+    def <<(line)
+      raise TypeError.new('expected Array') unless Array === line
+      @lines << line
+    end
+
+    # call-seq:
+    #   length -> Integer
+    #
+    # Returns number of lines in +self+ including all inform lines and the
+    # reply line, if present.
+    def length
+      @lines.length
+    end
+
+    # call-seq:
+    #   response[index] -> Array or nil
+    #   response[start, length] -> Array_of_Arrays or nil
+    #   response[range] -> Array_of_Arrays or nil
+    #
+    # Returns subset of lines.  Similar to Array#[].
+    def [](*args)
+      @lines[*args]
+    end
+
+    # call-seq:
+    #   reqname -> String
+    #
+    # Returns name of request corresponding to +self+ if complete, otherwise
+    # nil.
+    def reqname
+      # All but first character of first word of last line, if complete
+      @lines[-1][0][1..-1] if complete?
+    end
+
+    # call-seq:
+    #   complete? -> true_or_false
+    #
+    # Returns true if at least one line exists and the most recently added line
+    # is a reply line.
+    def complete?
+      # If at least one line exists, return true if last line, first word, first
+      # character is '!'.
+      @lines[-1] && @lines[-1][0][0,1] == '!'
+    end
+
+    # call-seq:
+    #   status -> String
+    #
+    # Returns status from reply line if complete, otherwise
+    # <tt>'incomplete'</tt>.
+    def status
+      complete? ? @lines[-1][1] : 'incomplete'
+    end
+
+    # call-seq:
+    #   ok? -> true_or_false
+    #
+    # Returns true if status is <tt>'ok'</tt>.
+    def ok?
+      'ok' == status
+    end
+
+    # call-seq:
+    #   sort! -> self
+    #
+    # Sorts the list of inform lines in-place and returns +self+
+    def sort!
+      n = complete? ? length-1 : length
+      @lines[0,n] = @lines[0,n].sort if n > 0
+      self
+    end
+
+    # call-seq:
+    #   sort -> KATCP::Response
+    #
+    # Returns a copy of +self+ with inform lines sorted
+    def sort
+      dup.sort!
+    end
+
+    # call-seq:
+    #   to_s -> String
+    #
+    # Rejoins words into lines and lines into one String
+    def to_s
+      @lines.map do |line|
+        line.join(' ')
+      end.join("\n")
+    end
+
+    # call-seq:
+    #   payload -> String or nil
+    #   payload(:to_i) -> Integer or nil
+    #   payload(:unpack, 'N*') -> Array_of_Integers or nil
+    #   payload(:to_na, NArray::INT) -> NArray_of_ints or nil
+    #   etc...
+    #
+    # Returns contents of reply line ("words" joined by spaces) after status
+    # word if <tt>ok?</tt> returns true.  Returns +nil+ if <tt>ok?</tt> is
+    # false or no payload exists.  If +args+ are given, they are sent to the
+    # payload String (via String#send) and the results are returned.
+    #
+    # For example, passing <tt>:to_i</tt> will result in conversion of payload
+    # String to Integer via String#to_i.  The String class can be
+    # monkey-patched as needed for additional conversion options.
+    def payload(*args)
+      if ok?
+        s = @lines[-1][2..-1].join(' ')
+        return s if args.empty?
+        s.send(*args)
+      end
+    end
+
+    # call-seq:
+    #   inspect -> String
+    #   inspect(mode) -> String
+    #
+    # Provides a terse (or not so terse) summary of +self+ depending on value
+    # of +mode+.  If given, +mode+ will be treated as inspect_mode.
+    def inspect(mode=@inspect_mode)
+      if mode && mode != :inspect?
+        send(mode) rescue inspect(nil)
+      else
+        s = "#<KATCP::Response:0x#{object_id.to_s(16)}> "
+        if complete?
+          s += "#{status}"
+          if @lines.length > 1
+            s += ", #{length-1} lines"
+          end
+        else
+          s += "#{length} lines, incomplete"
+        end
+      end
+    end
+  end # class Response
+end # module KATCP

data/lib/katcp/util.rb

@@ -0,0 +1,73 @@
+require 'narray'
+
+#TODO: Create ntoh! (etc) methods for narray
+
+# String add-ons for KATCP
+class String
+  # In-place escapes +self+ into KATCP format.  Always returns +self+.
+  def katcp_escape!
+    empty? ? self[0..-1] = '\@' : self.gsub!(/[\\ \0\n\r\e\t]/) do |s|
+      case s
+      when "\\": '\\'
+      when " " : '\_'
+      when "\0": '\0'
+      when "\n": '\n'
+      when "\r": '\r'
+      when "\e": '\e'
+      when "\t": '\t'
+      end
+    end
+    self
+  end
+
+  # Escapes +self+ into KATCP format and returns new String.
+  def katcp_escape
+    dup.katcp_escape!
+  end
+  
+  # In-place unescapes +self+ from KATCP format.  Always returns +self+.
+  def katcp_unescape!
+    self == '\@' ? self[0..-1] = '' : self.gsub!(/\\[\\_0nret]/) do |s|
+      case s
+      when '\\': "\\"
+      when '\_': " "
+      when '\0': "\0"
+      when '\n': "\n"
+      when '\r': "\r"
+      when '\e': "\e"
+      when '\t': "\t"
+      end
+    end
+    self
+  end
+
+  # Unescapes +self+ from KATCP format and returns new String.
+  def katcp_unescape
+    dup.katcp_unescape!
+  end
+
+  # call-seq:
+  #   to_na(typecode) -> NArray
+  #   to_na(typecode, byteswap) -> NArray
+  #   to_na(typecode,size[, ...]) -> NArray
+  #   to_na(typecode,size[, ...], byteswap) -> NArray
+  #
+  # Convert String to NArray accoring to +typecode+ and call byte swap method
+  # given by Symbol +byteswap+.  Pass +nil+ for +byteswap+ to skip the byte
+  # swap conversion.
+  #
+  # Because, as of this writing, KATCP servers typically run on big endian
+  # systems which return binary payload data in network byte order, the default
+  # +byteswap+ is <tt>:ntoh</tt>, which converts from network byte order to
+  # host (i.e. native) order.
+  def to_na(typecode, *args)
+    # Default to :ntoh
+    byteswap = :ntoh
+    if !args.empty? && (Symbol === args[-1] || args[-1].nil?)
+      byteswap = args.pop
+    end
+    na = NArray.to_na(self, typecode, *args)
+    na = na.send(byteswap) if byteswap
+    na
+  end
+end

data/lib/katcp/version.rb

@@ -0,0 +1,7 @@
+#--
+# Define KATCP::VERSION
+#++
+
+module KATCP
+  VERSION = "0.0.2"
+end

data/lib/katcp.rb

@@ -0,0 +1,2 @@
+# This pulls in everything
+require 'katcp/client/roach'

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: katcp
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- David MacMahon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-20 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: narray
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 5
+        - 9
+        version: 0.5.9
+  type: :runtime
+  version_requirements: *id001
+description: "    Provides KATCP client library for Ruby.  KATCP is the Karoo Array Telescope\n    Control Protocol.\n"
+email: davidm@astro.berkeley.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- lib/katcp.rb
+- lib/katcp/client.rb
+- lib/katcp/client/roach.rb
+- lib/katcp/irb.rb
+- lib/katcp/response.rb
+- lib/katcp/util.rb
+- lib/katcp/version.rb
+- examples/listdev.rb
+has_rdoc: true
+homepage: http://rb-katcp.rubyforge.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- -m
+- README
+- --title
+- Ruby/KATCP 0.0.2 Documentation
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 1
+      version: 1.8.1
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rb-katcp
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: KATCP library for Ruby
+test_files: []
+