onkyo_eiscp_ruby 0.0.2 → 2.1.1

data/lib/eiscp.rb

@@ -1,10 +1,12 @@
-# Create and send EISCP messages to control Onkyo receivers.
+# frozen_string_literal: true
 
-class EISCP
-  VERSION = '0.0.2'
+# Library for controlling Onkyo receivers over TCP/IP.
+#
+module EISCP
+  VERSION = '2.1.1'
 end
 
-require 'eiscp/eiscp'
-require 'eiscp/eiscp_packet'
-require 'eiscp/iscp_message'
-require 'eiscp/command'
+require_relative './eiscp/receiver'
+require_relative './eiscp/message'
+require_relative './eiscp/dictionary'
+require_relative './eiscp/parser'

data/lib/eiscp/dictionary.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+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(__dir__, '../../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|
+      @commands[zone][command][:values].merge! hash
+    rescue StandardError
+      puts "Failed to add #{hash} to #{zone}:#{command}:#{value}"
+    end
+  end
+end

data/lib/eiscp/dictionary/dictionary_generators.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+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
+        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
+        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
+        tmp
+      end
+    end
+  end
+end

data/lib/eiscp/dictionary/dictionary_helpers.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+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)
+          @commands[zone][command][:name]
+        rescue StandardError
+          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
+          nil
+
+        else
+
+          @commands[command_zone].each_pair do |command, attrs|
+            return command if attrs[:name] == name
+          end
+          nil
+
+        end
+      end
+
+      # Return a value name from a command and a value
+      def command_value_to_value_name(command, value)
+        zone = zone_from_command(command)
+        @commands[zone][command][:values][value][:name]
+      rescue StandardError
+        nil
+      end
+
+      # Return a value from a command and value name
+      def command_value_name_to_value(command, value_name)
+        zone = zone_from_command(command)
+        @commands[zone][command][:values].each_pair do |k, v|
+          if v[:name].class == String
+            return k if v[:name] == value_name.to_s
+          elsif v[:name].class == Array
+            return k if v[:name].first == value_name.to_s
+          end
+        end
+        return nil
+      rescue StandardError
+        nil
+      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|
+          return @commands[zone][command][:description] if attrs[:name] == name
+        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)
+        zone = zone_from_command(command)
+        @commands[zone].include? command
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/eiscp/message.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+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
+    # ISCP "magic" indicates the start of an eISCP message.
+    MAGIC = 'ISCP'
+    # eISCP header size, fixed length.
+    HEADER_SIZE = 16
+    # 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)
+        # STDERR.puts "Unknown command #{command}"
+      end
+
+      raise 'No value specified.' if value.nil?
+
+      @command = command
+      @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 }
+      begin
+        get_human_readable_attrs
+      rescue StandardError
+        # STDERR.puts"Couldn't get all human readable attrs"
+      end
+    end
+
+    # Check if two messages are equivalent comparing their ISCP messages.
+    #
+    def ==(other)
+      to_iscp == other.to_iscp
+    end
+
+    # Return ISCP Message string
+    #
+    def to_iscp
+      (@start + @unit_type + @command + @value).to_s
+    end
+
+    # Return EISCP Message string
+    #
+    def to_eiscp
+      [
+        @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.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+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.
+  #
+  module Parser
+    # Passes the string to the proper parser module's #parse method.
+    #
+    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/parser/dynamic_value_parser.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+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 @@
+# frozen_string_literal: true
+
+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 < RuntimeError; end
+  end
+end