onkyo_eiscp_ruby 0.0.2 → 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: be075bcd7a1830e7614b8384d610ea59d0b7160f
+  data.tar.gz: 40cea299c77c937a786f387cfbf4c11e8696632c
+SHA512:
+  metadata.gz: 5066d43a66350cb39e84ddbae87038d4ba04057f2dd884eee1852c3dd108ed4a44842878157dfb854e7802d3e771cbe5789a70af936af0e338a36264e92332d6
+  data.tar.gz: 6c2c8bb4ba7d3b7e9fee332d448a054cf97480194192252965b363b7efaa8d8b095ae76d2f68ab6f064fbf68ec2bac75c63b2ba53a26e891b055c0751f776cc4

data/README.md

@@ -1,41 +1,75 @@
 onkyo_eiscp_ruby
 ================
+[![Gem Version](https://badge.fury.io/rb/onkyo_eiscp_ruby.png)](http://badge.fury.io/rb/onkyo_eiscp_ruby)
 
 A Ruby implementation of eISCP for controlling Onkyo receivers.
 
 **This code is still under heavy development and using it might make you sick.**
-* Create ISCP messages and eISCP packets
-* Automatically discover receiver's in the broadcast domain
-* Send/Recieve eISCP messages
-* Open a TCP socket to send commands and receive solicited and non-solicited status updates.
-* Mock reciever (currently only responds to discovery)
+Create ISCP messages and eISCP packets
+Automatically discover receiver's in the broadcast domain
+Send/Recieve eISCP messages
+Open a TCP socket to send commands and receive solicited and non-solicited status updates.
+Mock reciever (currently only responds to discovery)
 
 **Inspired by https://github.com/miracle2k/onkyo-eiscp
 
-Usage
-________________
+**Protocol information from http://michael.elsdoerfer.name/onkyo/ISCP-V1.21_2011.xls
 
-	# require the library
 
-	require 'eiscp'
 
-	
-	# Discover local receivers
-	EISCP.discover
-	
-	
-	# Open a TCP connection to monitor solicited updates
-	eiscp = EISCP.new('10.0.0.1')
-	eiscp.connect
+Using the Library
+-----------------
+* require the library
 
-	# You can also pass a block and operate on received packet strings:
-	eiscp.connect do |data|
-	  puts EISCPPacket.parse(data).iscp_message
-	end
+		require 'eiscp'
 
-	# Turn on the receiver
-	iscp_message = ISCPMessage.new("PWR", "01")
-	eiscp_packet = EISCPPacket.new(iscp_message.message)
-	eiscp.send(eiscp_packet.to_s)
-	
+* Discover local receivers
 
+		EISCP::Receiver.discover
+
+* Create Receiver object from first discovered
+
+		Receiver.new
+
+* Open a TCP connection to monitor solicited updates
+
+		receiver = Receiver.new('10.0.0.1')
+		receiver.connect
+
+* You can also pass a block and operate on received packet strings:
+
+		receiver.connect do |data|
+		  puts EISCP::Receiver.parse(data).iscp_message
+		end
+
+* Turn on the receiver
+
+		message = EISCP::Message.parse("PWR", "01")
+		message.send(message.to_eiscp)
+
+* New 'parse' method makes creating EISCP objects more flexible.
+This parses messages from command line or raw eiscp data from the socket
+        
+		iscp_message = EISCP::Message.parse "PWR01"
+		iscp_message = EISCP::Message.parse "PWR 01"
+		iscp_message = EISCP::Message.parse "!1PWR01"
+		iscp_message = EISCP::Message.parse "!1PWR 01"
+
+* Parsing raw socket data
+
+		iscp_message_from_raw_eiscp = EISCP::Message.parse iscp_message.to_eiscp
+
+Using the Binaries
+------------------
+
+* Discover local receivers
+
+		$ onkyo.rb -d
+
+* Connect to the first discovered receiver to see status updates
+
+		$ onkyo.rb -c
+
+* Start the mock server (only responds to 'ECNQSTN')
+
+		$ onkyo-server.rb

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/bin/onkyo-server.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require 'eiscp/eiscp_server'
+require 'eiscp/mock_receiver'
 
 puts "Starting server on 60128..."
 
-EISCPServer.new
+EISCP::MockReceiver.new

data/bin/onkyo.rb

@@ -3,7 +3,6 @@
 require 'eiscp'
 require 'optparse'
 require 'ostruct'
-
 class Options
   DEFAULT_OPTIONS = { verbose: true, all: false }
   USAGE = ' Usage: onkyo_rb [options]'
@@ -48,8 +47,8 @@ class Options
     end
 
     if @options.discover
-      EISCP.discover.each do |receiver|
-        puts  EISCPPacket.parse(receiver[0]).to_s
+      EISCP::Receiver.discover.each do |receiver|
+        puts  EISCP::Message.parse(receiver[0]).to_iscp
       end
       exit 0
     end
@@ -60,8 +59,10 @@ class Options
     end
 
     if @options.connect
-      eiscp = EISCP.new(EISCP.discover[0][1])
-      eiscp.connect
+      eiscp = EISCP::Receiver.new(EISCP::Receiver.discover[0][1])
+      eiscp.connect do |data|
+        puts msg = EISCP::Receiver.parse(data).to_iscp
+      end
     end
 
     if ARGV == []
@@ -76,8 +77,9 @@ end
 @options = Options.parse(ARGV)
 
 
-eiscp = EISCP.new(EISCP.discover[0][1])
-eiscp.send_recv(EISCPPacket.new(ISCPMessage.new(ARGV[0], ARGV[1]).message).to_s)
+receiver = EISCP::Receiver.new(EISCP::Receiver.discover[0][1])
+message = (EISCP::Message.parse(ARGV.join(" ")).to_eiscp)
+puts receiver.send_recv message
 
 
 

data/lib/eiscp/command.rb

@@ -1,5 +1,5 @@
 require 'yaml'
-require 'eiscp/eiscp'
+require 'eiscp/receiver'
 require 'ostruct'
 
 module Command
@@ -11,19 +11,12 @@ module Command
   @@zones = @@yaml_object.map{|k, v| k}
   @@zones.each {|zone| class_variable_set("@@#{zone}", nil) }
   @@main = @@yaml_object['main']
-  
-
-  @@zones.each do |zone|
-    Command.class_variable_set("@@#{zone}", "[]")
-  end
-
-
 
   def self.command_to_name(command)
     return @@main[command]['name']
   end
 
-  def self.name_to_command(name)
+  def self.command_name_to_command(name)
     @@main.each_pair do |command, attrs|
       if attrs['name'] == name
         return command
@@ -44,10 +37,10 @@ module Command
   end
 
 
-  def self.description_from_name(name)
+  def self.description_from_command_name(name)
     @@main.each_pair do |command, attrs|
       if attrs['name'] == name
-        return command['description']
+        return @@main[command]['description']
       end
     end
   end
@@ -73,8 +66,34 @@ module Command
     end
   end
 
-  def self.list_compatible_commands
+  def self.list_compatible_commands(modelstring)
+    sets = [] 
+    @@modelsets.each_pair do |set, array|
+      if array.include? modelstring
+        sets << set
+      end
+    end
+    return sets
+  end
 
+  def self.parse(string)
+    array = string.split(" ")
+    zone = 'main'
+    command_name = ''
+    parameter_name = ''
+    if array.count == 3
+      zone = array.shift
+      command_name = array.shift
+      parameter_name = array.shift
+    elsif array.count == 2
+      command_name = array.shift
+      parameter_name = array.shift
+    end
+    command = Command.command_name_to_command(command_name)
+    parameter = Command.command_value_name_to_value(command, parameter_name)
+    return EISCP::Message.new(command, parameter)
   end
+
 end
 
+

data/lib/eiscp/message.rb

@@ -0,0 +1,99 @@
+module EISCP
+  class Message
+
+    # EISCP header
+    attr_accessor :header
+    MAGIC = "ISCP"
+    HEADER_SIZE = 16
+    ISCP_VERSION = "\x01"
+    RESERVED = "\x00\x00\x00"
+
+
+    # ISCP attrs
+    attr_accessor :start
+    attr_accessor :unit_type
+    attr_accessor :command
+    attr_accessor :parameter
+    attr_reader   :iscp_message
+
+
+    # REGEX
+    REGEX = /(?<start>!)?(?<unit_type>(\d|x))?(?<command>[A-Z]{3})\s?(?<parameter>.*)(?<end>\x1A)?/
+
+    def initialize(command, parameter, unit_type = "1", start = "!")
+      if unit_type == nil
+        @unit_type = "1"
+      else
+        @unit_type = unit_type
+      end
+      if start == nil
+        @start = "!"
+      else
+        @start = start
+      end
+      @command = command
+      @parameter = parameter
+      @iscp_message = [ @start, @unit_type, @command, @parameter ].inject(:+)
+      @header = { :magic => MAGIC, 
+                  :header_size => HEADER_SIZE, 
+                  :data_size => @iscp_message.length,
+                  :version => ISCP_VERSION, 
+                  :reserved => RESERVED 
+      }
+    end
+
+
+    # Check if two messages send the same command
+    def ==(message_object)
+      self.iscp_message == message_object.iscp_message ? true : false
+    end
+    # Identifies message format, calls appropriate parse function
+    # returns Message object.
+
+    def self.parse(string)
+      case string
+      when /^ISCP/
+        parse_eiscp_string(string)
+      when REGEX
+        parse_iscp_message(string)
+      else
+        puts "Not a valid ISCP or EISCP message."
+      end
+    end
+
+
+
+    # ISCP Message string parser
+
+    def self.parse_iscp_message(msg_string)
+      match = msg_string.match(REGEX)
+      Message.new(match[:command], match[:parameter], match[:unit_type], match[:start])
+    end
+
+    #parse eiscp_message string 
+    def self.parse_eiscp_string(eiscp_message_string)
+      array = eiscp_message_string.unpack("A4NNAa3A*")
+      iscp_message = Message.parse_iscp_message(array[5])
+      packet = Message.new(iscp_message.command, iscp_message.parameter, iscp_message.unit_type, iscp_message.start)
+      packet.header = { 
+        :magic => array[0],
+        :header_size => array[1],
+        :data_size => array[2],
+        :version => array[3],
+        :reserved => array[4]
+      }   
+      return packet
+    end
+
+    # Return ISCP Message string
+    def to_iscp
+      return "#{@start + @unit_type + @command + @parameter}"
+    end
+
+    # Return EISCP Message string
+    def to_eiscp
+      return [ @header[:magic], @header[:header_size], @header[:data_size], @header[:version], @header[:reserved], @iscp_message.to_s ].pack("A4NNAa3A*")
+    end
+
+  end
+end

data/lib/eiscp/mock_receiver.rb

@@ -0,0 +1,22 @@
+require 'socket'
+require 'eiscp/receiver'
+require 'eiscp/message'
+
+# Mock server that only responds to ECNQSTN.
+
+module EISCP
+  class MockReceiver
+
+    ONKYO_DISCOVERY_RESPONSE =  Message.new("ECN", "TX-NR609/60128/DX/001122334455")
+
+    # Create/start the server object.
+
+    def initialize
+      Socket.udp_server_loop("255.255.255.255", EISCP::ONKYO_PORT) do |msg, msg_src|
+        msg_src.reply ONKYO_DISCOVERY_RESPONSE.to_eiscp
+        puts msg
+      end
+    end
+
+  end
+end

data/lib/eiscp/receiver.rb

@@ -0,0 +1,180 @@
+require 'socket'
+require 'eiscp/message'
+require 'resolv'
+
+module EISCP
+  class Receiver
+
+    attr_accessor :host
+    attr_accessor :model
+    attr_accessor :port
+    attr_accessor :area
+    attr_accessor :mac_address
+
+    ONKYO_MAGIC = Message.new("ECN", "QSTN", "x").to_eiscp
+    ONKYO_PORT = 60128
+
+    # Create a new EISCP object to communicate with a receiver.
+    # If no host is given, use auto discovery and create a
+    # receiver object using the first host to respond.
+
+    def initialize(host = nil, port = ONKYO_PORT)
+      if host == nil
+        if first_rec = self.class.discover[0]
+          host = first_rec[1]
+          set_info first_rec[0]
+        else
+          raise Exception
+        end
+      end
+      @host = Resolv.getaddress host
+      @port = port
+      unless @model
+        set_info get_ecn
+      end
+    end
+
+    def set_info(ecn_string)
+      array = self.class.parse_ecn(ecn_string)
+      @model = array.shift
+      @port = array.shift.to_i
+      @area = array.shift
+      @mac_address = array.shift.split("\x19")[0]
+      return self
+    end
+
+    def get_ecn
+      self.class.discover.each do |entry|
+        if @host == entry[1]
+          return entry[0]
+        end
+      end
+    end
+
+    # Gets the ECNQSTN response of self using @host
+    # then parses it with parse_ecn, returning an array
+    # with receiver info
+
+    def get_ecn_array
+      self.class.discover.each do |entry|
+        if @host == entry[1]
+          array = self.class.parse_ecn(entry[0])
+        end
+        return array
+      end
+    end
+
+    # Returns array containing @model, @port, @area, and @mac_address
+    # from ECNQSTN response
+
+    def self.parse_ecn(ecn_string)
+      message = EISCP::Message.parse(ecn_string)
+      message.parameter.split("/")
+    end
+
+    # Internal method for receiving data with a timeout
+
+    def self.recv(sock, timeout = 0.5)
+      data = []
+      while true
+        ready = IO.select([sock], nil, nil, timeout)
+        if ready != nil
+          then readable = ready[0]
+        else
+          return data
+        end
+
+
+        readable.each do |socket|
+          begin
+            if socket == sock
+              data << sock.recv_nonblock(1024).chomp
+            end
+          rescue IO::WaitReadable
+            retry
+          end
+        end
+
+      end
+    end
+
+    # Returns an array of arrays consisting of a discovery response packet string
+    # and the source ip address of the reciever.
+
+    def self.discover
+      sock = UDPSocket.new
+      sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
+      sock.send(ONKYO_MAGIC, 0, '<broadcast>', ONKYO_PORT)
+      data = []
+      while true
+        ready = IO.select([sock], nil, nil, 0.5)
+        if ready != nil
+          then readable = ready[0]
+        else
+          return data
+        end
+
+
+        readable.each do |socket|
+          begin
+            if socket == sock
+              msg, addr = sock.recvfrom_nonblock(1024)
+              data << [msg, addr[2]]
+            end
+          rescue IO::WaitReadable
+            retry
+          end
+        end
+
+      end
+    end
+
+    # Sends a packet string on the network
+
+    def send(eiscp_packet)
+      sock = TCPSocket.new @host, @port
+      sock.puts eiscp_packet
+      sock.close
+    end
+
+    # Send a packet string and return recieved data string.
+
+    def send_recv(eiscp_packet)
+      sock = TCPSocket.new @host, @port
+      sock.puts eiscp_packet
+      return Receiver.recv(sock, 0.5)
+    end
+
+    # Open a TCP connection to the host and print all received messages until
+    # killed.
+
+    def connect(&block)
+      sock = TCPSocket.new @host, @port
+      while true
+        ready = IO.select([sock], nil, nil, nil)
+        if ready != nil
+          then readable = ready[0]
+        else
+          return
+        end
+
+        readable.each do |socket|
+          begin
+            if socket == sock
+              data = sock.recv_nonblock(1024).chomp
+              if block_given?
+                yield data
+              else
+                puts data
+              end
+            end
+          rescue IO::WaitReadable
+            retry
+          end
+        end
+
+      end
+    end
+
+  end
+end

data/lib/eiscp.rb

@@ -1,10 +1,9 @@
-# Create and send EISCP messages to control Onkyo receivers.
+# Library for controlling Onkyo receivers over TCP/IP.
 
-class EISCP
-  VERSION = '0.0.2'
+module EISCP
+  VERSION = '0.0.3'
 end
 
-require 'eiscp/eiscp'
-require 'eiscp/eiscp_packet'
-require 'eiscp/iscp_message'
+require 'eiscp/receiver'
+require 'eiscp/message'
 require 'eiscp/command'

data/onkyo_eiscp_ruby.gemspec

@@ -11,7 +11,8 @@ Gem::Specification.new do |s|
   s.homepage     = "https://github.com/mikerodrigues/onkyo_eiscp_ruby"
 
   s.description  = %q(
-    Use the provided binary script or require the library for use in your scripts.
+    Control Onkyo receivers over the network.Use the provided binary script or
+    require the library for use in your scripts.
   )
 
   s.author       = "Michael Rodrigues"

data/test/tc_command.rb

@@ -1,4 +1,5 @@
 require_relative "../lib/eiscp/command.rb"
+require_relative "../lib/eiscp/message.rb"
 require "test/unit"
 
 class TestCommand < Test::Unit::TestCase
@@ -7,8 +8,8 @@ class TestCommand < Test::Unit::TestCase
     assert_equal(Command.command_to_name("PWR"), "system-power")
   end
 
-  def test_name_to_command
-    assert_equal(Command.name_to_command("system-power"), "PWR")
+  def test_command_name_to_command
+    assert_equal(Command.command_name_to_command("system-power"), "PWR")
   end
 
   def test_command_value_to_value_name
@@ -19,12 +20,24 @@ class TestCommand < Test::Unit::TestCase
     assert_equal(Command.command_value_name_to_value("PWR", "on"), "01")
   end
 
-  def test_description_from_name
-    assert_equal(Command.description_from_name("system-power"), "System Power Command")
+  def test_description_from_command_name
+    assert_equal(Command.description_from_command_name("system-power"), "System Power Command")
   end
 
   def test_description_from_command
     assert_equal(Command.description_from_command("PWR"), "System Power Command")
   end
 
+  def test_parse_system_power
+    assert_equal(Command.parse('system-power on'), EISCP::Message.parse('PWR01'))
+  end
+
+  def test_parse_zone2_system_power
+    assert_equal(Command.parse('zone2 power on'), EISCP::Message.parse('ZPW01'))
+  end
+
+  def test_parse_volume_as_integer
+    assert_equal(Command.parse('main-volume 25'), EISCP::Message.parse('MVL19'))
+  end
+
 end

data/test/tc_message.rb

@@ -0,0 +1,27 @@
+require_relative "../lib/eiscp/message"
+require "test/unit"
+
+class TestMessage <  Test::Unit::TestCase
+
+  
+  DISCOVERY_PACKET = EISCP::Message.new('ECN', 'QSTN', 'x', '!')
+  DISCOVERY_STRING = DISCOVERY_PACKET.to_eiscp
+
+
+  def test_create_discovery_iscp_message
+    assert_equal(EISCP::Message.new("ECN", "QSTN", "x", "!").to_iscp, "!xECNQSTN")
+  end
+
+  def test_parse_discovery_iscp_message
+    assert_equal(EISCP::Message.parse("!xECNQSTN").to_iscp, "!xECNQSTN")
+  end
+
+  def test_create_discovery_packet_string
+    assert_equal(DISCOVERY_PACKET.to_eiscp, DISCOVERY_STRING)
+  end
+
+  def test_parse_discovery_packet_string
+    assert_equal(EISCP::Message.parse(DISCOVERY_STRING).to_eiscp, DISCOVERY_PACKET.to_eiscp)
+  end
+
+end

data/test/{tc_eiscp.rb → tc_receiver.rb}

@@ -1,4 +1,4 @@
-require_relative "../lib/eiscp/eiscp.rb"
+require_relative "../lib/eiscp/receiver"
 require "test/unit"
 
 class TestEISCP

metadata

@@ -1,18 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: onkyo_eiscp_ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.2
-  prerelease: 
+  version: 0.0.3
 platform: ruby
 authors:
 - Michael Rodrigues
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-02 00:00:00.000000000 Z
+date: 2014-01-20 00:00:00.000000000 Z
 dependencies: []
-description: ! "\n    Use the provided binary script or require the library for use
-  in your scripts.\n  "
+description: "\n    Control Onkyo receivers over the network.Use the provided binary
+  script or\n    require the library for use in your scripts.\n  "
 email: mikebrodrigues@gmail.com
 executables:
 - onkyo.rb
@@ -21,49 +20,44 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
+- README.md
+- VERSION
 - bin/onkyo-server.rb
 - bin/onkyo.rb
-- lib/eiscp/eiscp_server.rb
-- lib/eiscp/eiscp.rb
-- lib/eiscp/eiscp_packet.rb
-- lib/eiscp/command.rb
-- lib/eiscp/iscp_message.rb
+- eiscp-commands.yaml
 - lib/eiscp.rb
-- test/tc_command.rb
-- test/tc_iscp_message.rb
-- test/tc_eiscp.rb
-- test/tc_eiscp_packet.rb
-- VERSION
+- lib/eiscp/command.rb
+- lib/eiscp/message.rb
+- lib/eiscp/mock_receiver.rb
+- lib/eiscp/receiver.rb
 - onkyo_eiscp_ruby.gemspec
-- eiscp-commands.yaml
-- README.md
+- test/tc_command.rb
+- test/tc_message.rb
+- test/tc_receiver.rb
 homepage: https://github.com/mikerodrigues/onkyo_eiscp_ruby
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Manipulate Onkyo stereos with the eISCP protocol
 test_files:
+- test/tc_message.rb
+- test/tc_receiver.rb
 - test/tc_command.rb
-- test/tc_iscp_message.rb
-- test/tc_eiscp.rb
-- test/tc_eiscp_packet.rb
-has_rdoc: 

data/lib/eiscp/eiscp.rb

@@ -1,125 +0,0 @@
-require 'socket'
-require 'eiscp/eiscp_packet.rb'
-require 'eiscp/iscp_message.rb'
-
-class EISCP
-  ONKYO_PORT = 60128
-  ONKYO_MAGIC = EISCPPacket.new("ECN", "QSTN", "x").to_s
-
-  # Create a new EISCP object to communicate with a receiver.
-
-  def initialize(host)
-    @host = host
-  end
-
-  # Internal method for receiving data with a timeout
-
-  def self.recv(sock, timeout = 0.5)
-    data = []
-    while true
-      ready = IO.select([sock], nil, nil, timeout)
-      if ready != nil
-        then readable = ready[0]
-      else
-        return data
-      end
-
-
-      readable.each do |socket|
-        begin
-          if socket == sock
-            data << sock.recv_nonblock(1024).chomp
-          end
-        rescue IO::WaitReadable
-          retry
-        end
-      end
-
-    end
-  end
-  
-  # Returns an array of arrays consisting of a discovery response packet string
-  # and the source ip address of the reciever.
-
-  def self.discover
-    sock = UDPSocket.new
-    sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
-    sock.send(ONKYO_MAGIC, 0, '<broadcast>', ONKYO_PORT)
-    data = []
-    while true
-      ready = IO.select([sock], nil, nil, 0.5)
-      if ready != nil
-        then readable = ready[0]
-      else
-        return data
-      end
-
-
-      readable.each do |socket|
-        begin
-          if socket == sock
-            msg, addr = sock.recvfrom_nonblock(1024)
-            data << [msg, addr[2]]
-          end
-        rescue IO::WaitReadable
-          retry
-        end
-      end
-
-    end
-  end
-  
-  # Sends a packet string on the network
-
-  def send(eiscp_packet)
-    sock = TCPSocket.new @host, ONKYO_PORT
-    sock.puts eiscp_packet
-    sock.close
-  end
-
-  # Send a packet string and return recieved data string.
-  
-  def send_recv(eiscp_packet)
-    sock = TCPSocket.new @host, ONKYO_PORT
-    sock.puts eiscp_packet
-    puts EISCP.recv(sock, 0.5)
-  end
-
-  # Open a TCP connection to the host and print all received messages until
-  # killed.
-
-  def connect(&block)
-    sock = TCPSocket.new @host, ONKYO_PORT
-    while true
-      ready = IO.select([sock], nil, nil, nil)
-      if ready != nil
-        then readable = ready[0]
-      else
-        return
-      end
-
-      readable.each do |socket|
-        begin
-          if socket == sock
-            data = sock.recv_nonblock(1024).chomp
-            if block_given?
-              yield data
-            else
-              puts data
-            end
-          end
-        rescue IO::WaitReadable
-          retry
-        end
-      end
-
-    end
-  end
-
-end
-
-
-
-
-
-

data/lib/eiscp/eiscp_packet.rb

@@ -1,51 +0,0 @@
-require 'eiscp/iscp_message'
-
-# Public: Encapsulates ISCP Messages in eISCP packets to send on the network.
-# You can alsoe use the class method 'parse' to create objects from strings
-# captured from the network using the EISCP class.
-
-class EISCPPacket
-  
-  MAGIC = "ISCP"
-  HEADER_SIZE = 16
-  VERSION = "\x01"
-  RESERVED = "\x00\x00\x00"
-
-  attr_accessor :header
-  attr_reader :iscp_message
-
-  # Create a new EISCPPacket object with a given command and parameter
-  # -+command+ - an ISCP command like "PWR" for "system-power"
-  # -+parameter+ - an ISCP command parameter like "01" for "on" for 
-  # "system-power"
-  
-  def initialize(command, parameter, unit_type = "1", start = "!")
-    @iscp_message = ISCPMessage.new(command, parameter, unit_type, start)
-    @header = { :magic => MAGIC, :header_size => HEADER_SIZE, :data_size => @iscp_message.to_s.length, :version => VERSION, :reserved => RESERVED }
-  end
-
-  # Returns a raw packet string for sending on the network using EISCP object.
-
-  def to_s
-    return [ @header[:magic], @header[:header_size], @header[:data_size], @header[:version], @header[:reserved], @iscp_message.to_s ].pack("A4NNAa3A*")
-  end
-
-  # Returns an EISCPPacket from a raw packet string
-
-  def self.parse(eiscp_message_string)
-    array = eiscp_message_string.unpack("A4NNAa3A*")
-    iscp_message = ISCPMessage.parse(array[5])
-    packet = EISCPPacket.new(iscp_message.command, iscp_message.parameter, iscp_message.unit_type, iscp_message.start)
-    packet.header = {
-      :magic => array[0],
-      :header_size => array[1],
-      :data_size => array[2],
-      :version => array[3],
-      :reserved => array[4]
-    }
-    return packet
-  end
-
-end
-
-

data/lib/eiscp/eiscp_server.rb

@@ -1,21 +0,0 @@
-require 'socket'
-require 'eiscp/eiscp_packet'
-require 'eiscp/eiscp'
-
-# Mock server that only responds to ECNQSTN.
-
-class EISCPServer
-
-  ONKYO_DISCOVERY_RESPONSE =  EISCPPacket.new("ECN", "TX-NR609/60128/DX/001122334455")
-
-  # Create/start the server object.
-
-  def initialize
-    Socket.udp_server_loop("255.255.255.255", EISCP::ONKYO_PORT) do |msg, msg_src|
-      msg_src.reply ONKYO_DISCOVERY_RESPONSE.to_s
-      puts msg
-    end
-  end
-
-end
-

data/lib/eiscp/iscp_message.rb

@@ -1,24 +0,0 @@
-class ISCPMessage
-
-  attr_accessor :start
-  attr_accessor :unit_type
-  attr_accessor :command
-  attr_accessor :parameter
-
-  def initialize(command, parameter, unit_type = "1", start = "!")
-    @unit_type = unit_type
-    @start = start
-    @command = command
-    @parameter = parameter
-  end
-
-  def self.parse(msg_string)
-    match = msg_string.match(/(?<start>!)(?<unit_type>\w)(?<command>[A-Z]{3})(?<parameter>\S+)/)
-    ISCPMessage.new(match[:command], match[:parameter], match[:unit_type], match[:start])
-  end
-
-  def to_s
-    return "#{@start + @unit_type + @command + @parameter}\r"
-  end
-
-end

data/test/tc_eiscp_packet.rb

@@ -1,17 +0,0 @@
-require_relative "../lib/eiscp/eiscp_packet.rb"
-require "test/unit"
-
-class TestEISCPPacket < Test::Unit::TestCase
-
-  DISCOVERY_STRING = "ISCP\x00\x00\x00\x10\x00\x00\x00\n\x01\x00\x00\x00!xECNQSTN\r"
-  DISCOVERY_PACKET = EISCPPacket.new('ECN', 'QSTN', 'x', '!')
-
-  def test_create_discovery_packet_string
-    assert_equal(DISCOVERY_PACKET.to_s, DISCOVERY_STRING)
-  end
-
-  def test_parse_discovery_packet_string
-    assert_equal(EISCPPacket.parse(DISCOVERY_STRING).to_s, DISCOVERY_PACKET.to_s)
-  end
-
-end

data/test/tc_iscp_message.rb

@@ -1,14 +0,0 @@
-require_relative "../lib/eiscp/iscp_message.rb"
-require "test/unit"
-
-class TestISCPMessage <  Test::Unit::TestCase
-
-  def test_create_discovery_iscp_message
-    assert_equal(ISCPMessage.new("ECN", "QSTN", "x", "!").to_s, "!xECNQSTN\r")
-  end
-
-  def test_parse_discovery_iscp_message
-    assert_equal(ISCPMessage.parse("!xECNQSTN\r").to_s, "!xECNQSTN\r")
-  end
-
-end