onkyo_eiscp_ruby 0.0.3 → 1.0.4

data/lib/eiscp/dictionary/dictionary_generators.rb

@@ -0,0 +1,67 @@
+require 'yaml'
+
+module EISCP
+  module Dictionary
+    # This module provides methods that can be used to generate command entries
+    # that are specified as ranges in the yaml file.
+    #
+    module DictionaryGenerators
+      # Creates a hash object for range commands like master-volume
+      #
+      def create_range_commands(zone, command, value)
+        case value.count
+        when 3
+          range = Range.new(value[0], value[2])
+        when 2
+          range = Range.new(*value)
+        end
+        tmp = {}
+        range.each do |number|
+          tmp.merge!(number.to_s(16).rjust(2, '0').upcase =>
+            {
+              :name => number.to_s,
+              :description =>
+                @commands[zone][command][:values][value][:description].gsub(/\d - \d+/, number.to_s),
+              :models => @commands[zone][command][:values][value][:models]
+            }
+          )
+        end
+        return tmp
+      end
+
+      # Creates hash object for treble and bass commands
+      #
+      def create_treble_bass_commands(zone, command, value)
+        tmp = {}
+        ['-A', '-8', '-6', '-4', '-2', '00', '+2', '+4', '+6', '+8', '+A'].each do |v|
+          tmp.merge!((value[0] + v.to_s) =>
+            {
+              :name => value[0].downcase + v,
+              :description =>
+                @commands[zone][command][:values][value[0] + '{xx}'][:description].gsub(/\(.*[\]|\)]$/, v),
+              :models => @commands[zone][command][:values][value[0] + '{xx}'][:models]
+            }
+          )
+        end
+        return tmp
+      end
+
+      # Creates hash object for balance commands
+      #
+      def create_balance_commands(zone, command, _value)
+        tmp = {}
+        ['-A', '-8', '-6', '-4', '-2', '00', '+2', '+4', '+6', '+8', '+A'].each do |v|
+          tmp.merge!(v.to_s =>
+            {
+              :name => v.downcase,
+              :description =>
+                @commands[zone][command][:values]['{xx}'][:description].gsub(/\(.*[\]|\)]$/, v),
+              :models => @commands[zone][command][:values]['{xx}'][:models]
+            }
+          )
+        end
+        return tmp
+      end
+    end
+  end
+end

data/lib/eiscp/dictionary/dictionary_helpers.rb

@@ -0,0 +1,118 @@
+module EISCP
+  module Dictionary
+    # This module provides methods to get information from the Dictionary about
+    # commands, values, zones, and models.
+    #
+    module DictionaryHelpers
+      # Return the zone that includes the given command
+      def zone_from_command(command)
+        @zones.each do |zone|
+          @commands[zone].each_pair do |k, _|
+            return zone if command == k
+          end
+        end
+        nil
+      end
+
+      # Return the human readable name of a command
+      def command_to_name(command)
+        command = command.upcase
+        begin
+          zone = zone_from_command(command)
+          return @commands[zone][command][:name]
+        rescue
+          return nil
+        end
+      end
+
+      # Return the command from a given command name
+      def command_name_to_command(name, command_zone = nil)
+        if command_zone.nil?
+
+          @zones.each do |zone|
+            @commands[zone].each_pair do |command, attrs|
+              return command if attrs[:name] == name
+            end
+          end
+          return nil
+
+        else
+
+          @commands[command_zone].each_pair do |command, attrs|
+            return command if attrs[:name] == name
+          end
+          return nil
+
+        end
+      end
+
+      # Return a value name from a command and a value
+      def command_value_to_value_name(command, value)
+        begin
+          zone = zone_from_command(command)
+          @commands[zone][command][:values][value][:name]
+        rescue
+          nil
+        end
+      end
+
+      # Return a value from a command and value name
+      def command_value_name_to_value(command, value_name)
+        begin
+          zone = zone_from_command(command)
+          @commands[zone][command][:values].each_pair do |k, v|
+            return k if v[:name] == value_name.to_s
+          end
+        rescue
+          nil
+        end
+      end
+
+      # Return a command description from a command name and zone
+      def description_from_command_name(name, zone)
+        @commands[zone].each_pair do |command, attrs|
+          if attrs[:name] == name
+            return @commands[zone][command][:description]
+          end
+        end
+        nil
+      end
+
+      # Return a command description from a command
+      def description_from_command(command)
+        zone = zone_from_command(command)
+        @commands[zone][command][:description]
+      end
+
+      # Return a value description from a command and value
+      def description_from_command_value(command, value)
+        zone = zone_from_command(command)
+        @commands[zone][command][:values].select do |k, v|
+          return v[:description] if k == value
+        end
+        nil
+      end
+
+      # Return a list of commands compatible with a given model
+      def list_compatible_commands(modelstring)
+        sets = []
+        @modelsets.each_pair do |set, array|
+          sets << set if array.include? modelstring
+        end
+        sets
+      end
+
+      # Checks to see if the command is in the Dictionary
+      #
+      def known_command?(command)
+        begin
+          zone = zone_from_command(command)
+          @commands[zone].include? command
+        rescue
+          return nil
+        end
+      end
+    end
+
+  end
+end

data/lib/eiscp/dictionary.rb

@@ -0,0 +1,54 @@
+require_relative './dictionary/dictionary_generators'
+require_relative './dictionary/dictionary_helpers'
+
+module EISCP
+  # This module provides an interface to the information from the yaml file. It
+  # uses DictionaryGenerators to add commands specified by ranges in the yaml
+  # file. It uses DictionaryHelpers to convert commands and values to and from
+  # their human readable form.
+  #
+  module Dictionary
+    extend DictionaryGenerators
+    extend DictionaryHelpers
+
+    class << self
+      attr_reader :zones
+      attr_reader :modelsets
+      attr_reader :commands
+    end
+
+    DEFAULT_ZONE = 'main'
+    @yaml_file_path = File.join(File.expand_path(File.dirname(__FILE__)), '../../eiscp-commands.yaml')
+    @commands = YAML.load(File.read(@yaml_file_path))
+    @modelsets = @commands[:modelsets]
+    @commands.delete(:modelsets)
+    @zones = @commands.map { |k, _| k }
+
+    @additions = []
+    @commands.each_key do |zone|
+      @commands[zone].each do |command|
+        command = command[0]
+        @commands[zone][command][:values].each do |value|
+          value = value[0]
+          if value.is_a? Array
+            @additions << [zone, command, value, create_range_commands(zone, command, value)]
+          elsif value.match(/^(B|T){xx}$/)
+            @additions << [zone, command, value, create_treble_bass_commands(zone, command, value)]
+          elsif value.match(/^{xx}$/)
+            @additions << [zone, command, value, create_balance_commands(zone, command, value)]
+          else
+            next
+          end
+        end
+      end
+    end
+
+    @additions.each do |zone, command, value, hash|
+      begin
+        @commands[zone][command][:values].merge! hash
+      rescue
+        puts "Failed to add #{hash} to #{zone}:#{command}:#{value}"
+      end
+    end
+  end
+end

data/lib/eiscp/message.rb

@@ -1,99 +1,123 @@
+# encoding: utf-8
+require_relative './dictionary'
+require_relative './parser'
+
 module EISCP
+  # The EISCP::Message class is used to handle commands and responses.
+  #
+  # Messages can be parsed directly from raw data or created with values:
+  #   receiver = Receiver.new
+  #
+  #   command = EISCP::Message.new('PWR', 'QSTN')
+  #   response = EISCP::Parser.parse(receiver.send_recv(command))
+  #
   class Message
-
     # EISCP header
     attr_accessor :header
-    MAGIC = "ISCP"
+    # ISCP "magic" indicates the start of an eISCP message.
+    MAGIC = 'ISCP'
+    # eISCP header size, fixed length.
     HEADER_SIZE = 16
-    ISCP_VERSION = "\x01"
+    # ISCP protocol version.
+    ISCP_VERSION = 1
+    # Reserved for future protocol updates.
     RESERVED = "\x00\x00\x00"
 
+    # ISCP Start character, usually "!"
+    attr_reader :start
+    # ISCP Unit Type character, usually "1"
+    attr_reader :unit_type
+    # ISCP Command
+    attr_reader :command
+    # Human readable command name
+    attr_reader :command_name
+    # Command description
+    attr_reader :command_description
+    # ISCP Command Value
+    attr_reader :value
+    # Human readable value name
+    attr_reader :value_name
+    # Value description
+    attr_reader :value_description
+    # ISCP Zone
+    attr_reader :zone
+    # Differentiates parsed messages from command messages
+    attr_reader :parsed
+
+    # Terminator character for eISCP packets
+    attr_reader :terminator
+
+    # Create an ISCP message
+    # @param [String] command three-character length ISCP command
+    # @param [String] value variable length ISCP command value
+    # @param [String] unit_type_character override default unit type character, optional
+    # @param [String] start_character override default start character, optional
+    def initialize(command: nil, value: nil, terminator:  "\r\n", unit_type: '1', start: '!')
+      unless Dictionary.known_command?(command)
+        warn "Unknown command #{command}"
+      end
 
-    # 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)?/
+      fail 'No value specified.' if value.nil?
 
-    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 
+      @value = value
+      @terminator = terminator
+      @unit_type = unit_type
+      @start = start
+      @header = { magic: MAGIC,
+                  header_size:  HEADER_SIZE,
+                  data_size: to_iscp.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."
+      begin
+        get_human_readable_attrs
+      rescue
+        warn "Couldn't get all human readable attrs"
       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
+    # Check if two messages are equivalent comparing their ISCP messages.
+    #
+    def ==(other)
+      to_iscp == other.to_iscp ? true : false
     end
 
     # Return ISCP Message string
+    #
     def to_iscp
-      return "#{@start + @unit_type + @command + @parameter}"
+      "#{@start + @unit_type + @command + @value}"
     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*")
+      [
+        @header[:magic],
+        @header[:header_size].to_i,
+        @header[:data_size].to_i,
+        @header[:version].to_i,
+        @header[:reserved],
+        to_iscp.to_s,
+        @terminator
+      ].pack('A4NNCa3A*A*')
+    end
+
+    # Return human readable description.
+    #
+    def to_s
+      "#{@zone} - #{@command_name}:#{@value_name}"
     end
 
+    private
+
+    # Retrieves human readable attributes from the yaml file via Dictionary
+    def get_human_readable_attrs
+      @zone = Dictionary.zone_from_command(@command)
+      @command_name = Dictionary.command_to_name(@command)
+      @command_description = Dictionary.description_from_command(@command)
+      @value_name = Dictionary.command_value_to_value_name(@command, @value)
+      @value_description = Dictionary.description_from_command_value(@command, @value)
+    end
   end
 end

data/lib/eiscp/parser/dynamic_value_parser.rb

@@ -0,0 +1,7 @@
+module EISCP
+  module Parser
+    module DynamicValueParser
+      # Still trying to sort this out.
+    end
+  end
+end

data/lib/eiscp/parser/eiscp_parser.rb

@@ -0,0 +1,37 @@
+require_relative '../message'
+require_relative './iscp_parser'
+
+module EISCP
+  module Parser
+    # This module parses an eISCP string and returns a Message object
+    #
+    module EISCPParser
+      def self.parse(string)
+        array = string.unpack('A4NNCa3A*')
+        msg = ISCPParser.parse(array[5])
+        packet = Message.new(
+          command: msg.command,
+          value: msg.value,
+          terminator: msg.terminator,
+          unit_type: msg.unit_type,
+          start: msg.start
+        )
+        packet.header = {
+          magic: array[0],
+          header_size: array[1],
+          data_size: array[2],
+          version: array[3],
+          reserved: array[4]
+        }
+        packet
+      end
+
+      def self.validate(packet)
+        packet.header.header_size.size == packet.command.size
+      end
+    end
+
+    class EISCPParserException < Exception; end
+
+  end
+end

data/lib/eiscp/parser/human_readable_parser.rb

@@ -0,0 +1,30 @@
+require_relative '../message'
+require_relative '../dictionary'
+
+module EISCP
+  module Parser
+    # This module parses a human readable command and returns a Message object
+    #
+    module HumanReadableParser
+      def self.parse(string)
+        array = string.split(' ')
+
+        if Dictionary.zones.include? array[0]
+          parsed_zone = array.shift
+        else
+          parsed_zone = Dictionary::DEFAULT_ZONE
+        end 
+
+        command_name = array.shift
+        value_name = array.join(" ")
+        command = Dictionary.command_name_to_command(command_name, parsed_zone)
+        value = Dictionary.command_value_name_to_value(command, value_name)
+        if (command.nil? || value.nil?)
+          return nil
+        end
+        Message.new(command: command, value: value)
+      end
+
+    end
+  end
+end

data/lib/eiscp/parser/iscp_parser.rb

@@ -0,0 +1,29 @@
+require_relative '../message'
+
+module EISCP
+  module Parser
+    # This module parses an ISCP string and returns a Message object
+    #
+    module ISCPParser
+      # Regexp for parsing ISCP messages
+      REGEX = /(?<start>!)?(?<unit_type>(\d|x))?(?<command>[A-Z]{3})\s?(?<value>.*?)(?<terminator>[[:cntrl:]]*$)/
+      def self.parse(string)
+        match = string.match(REGEX)
+
+        # Convert MatchData to Hash
+        hash = Hash[match.names.zip(match.captures)]
+
+        # Remove nil and blank values
+        hash.delete_if { |_, v| v.nil? || v == '' }
+
+        # Convert keys to symbols
+        hash = hash.inject({}) do |memo, (k, v)|
+          memo[k.to_sym] = v
+          memo
+        end
+
+        Message.new(**hash)
+      end
+    end
+  end
+end

data/lib/eiscp/parser.rb

@@ -0,0 +1,22 @@
+require_relative './parser/eiscp_parser'
+require_relative './parser/iscp_parser'
+require_relative './parser/human_readable_parser'
+
+module EISCP
+  # This module provides an interface to the other parser modules. It identifies
+  # the type of string to be parsed and then passes the string off to the
+  # appropriate parser module.
+  #
+  module Parser
+    def self.parse(string)
+      case string
+      when /^ISCP/
+        EISCPParser.parse(string)
+      when ISCPParser::REGEX
+        ISCPParser.parse(string)
+      else
+        HumanReadableParser.parse(string)
+      end
+    end 
+  end
+end

data/lib/eiscp/receiver/command_methods.rb

@@ -0,0 +1,29 @@
+require_relative '../parser'
+require_relative '../dictionary'
+
+module EISCP
+  class Receiver
+    # Iterates through every available command and defines a method to call that
+    # command. It's intended to be used through Receiver and uses methods included
+    # by Receiver::Connection. Each method accepts a string that should match the
+    # human readable name of a valid value for that command.
+    #
+    module CommandMethods
+      def self.generate
+        Dictionary.zones.each do |zone|
+          Dictionary.commands[zone].each do |command, _values|
+            begin
+              command_name = Dictionary.command_to_name(command).to_s.gsub(/-/, '_')
+              define_method(command_name) do |v|
+                yield Parser.parse(command_name.gsub(/_/, '-') + ' ' + v)
+              end
+            rescue => e
+              puts e
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/eiscp/receiver/connection.rb

@@ -0,0 +1,83 @@
+require 'socket'
+require_relative '../parser'
+
+module EISCP
+  class Receiver
+    # This module handles connecting, sending, and receiving for Receivers.
+    #
+    module Connection
+      # Receiver's connection socket
+      attr_reader :socket
+      # Receiver's connection thread
+      attr_reader :thread
+      # Most recent message received
+      attr_reader :last
+
+      # Default connection timeout value in seconds
+      DEFAULT_TIMEOUT = 0.5
+
+      # Default Onkyo eISCP port
+      ONKYO_PORT = 60_128
+
+      # Create a new connection thread. Also accepts a block that will run
+      # whenver a message is received. You can pass the Message object in with
+      # your block. This is the method #new uses to create the initial thread.
+      #
+      def update_thread
+        @thread && @thread.kill
+        @thread = Thread.new do
+          loop do
+            recv
+            yield(@last) if block_given?
+          end
+        end
+      end
+
+      # This handles the background thread for monitoring messages from the
+      # receiver.
+      #
+      # If a block is given, it can be used to setup a callback when a message
+      # is received.
+      #
+      def connect(host, port = ONKYO_PORT, &block)
+        begin
+          @socket = TCPSocket.new(host, port)
+          update_thread(&block)
+        rescue => e
+          puts e
+        end
+      end
+
+      # Sends an EISCP::Message object or string on the network
+      #
+      def send(eiscp)
+        if eiscp.is_a? EISCP::Message
+          @socket.puts(eiscp.to_eiscp)
+        elsif eiscp.is_a? String
+          @socket.puts eiscp
+        end
+      end
+
+      # Reads the socket and returns and EISCP::Message
+      #
+      def recv
+        message = ''
+        message << @socket.gets until message.match(/\r\n$/) do
+          @last = Parser.parse(message)
+        end
+      end
+
+      # Sends an EISCP::Message object or string on the network and returns recieved data string.
+      #
+      def send_recv(eiscp)
+        if eiscp.is_a? EISCP::Message
+          @socket.puts(eiscp.to_eiscp)
+        elsif eiscp.is_a? String
+          @socket.puts(eiscp)
+        end
+        sleep DEFAULT_TIMEOUT
+        last
+      end
+    end
+  end
+end