yamaha 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8f14111abebd3540efa54a52c6f3ceef20b5217879c6df1aa57e1aa293fea037
+  data.tar.gz: e8142bbe221620dc2d0e86a831fb58d5a21ef4c3099a08d05e674271ecefbe29
+SHA512:
+  metadata.gz: 3bb84d02c1209763e280e294b5049c89b77e7518d11a131fc641acf0a030cc20dac6334db079064cb183a159a7d47b611b6638ac39f4056b4a902dd8dda6d79f
+  data.tar.gz: d677cba18bbd2c20f2d89c7902a5f1f82669635038709d3e551ea07e2d6f2f435856a68932c36c1603e3ee49a1b1dd5d3d6bc2d7c18b723eead3c58ad3b6b13d

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2022 Oleg Pudeyev
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,74 @@
+# Yamaha Receiver Serial Control Ruby Library
+
+## Protocol Notes
+
+### RX-V1500 Power Values
+
+You might expect the power state to be a bit field, but it isn't - each
+combination appears to have been assigned an independent value:
+
+| Main zone | Zone 2 | Zone 3 | Value | Notes
+| On        | On     | On     | 1     | All on
+| On        | On     | Off    | 4     |
+| On        | Off    | On     | 5     |
+| On        | Off    | Off    | 2     |
+| Off       | On     | On     | 3     |
+| Off       | On     | Off    | 6     |
+| Off       | Off    | On     | 7     |
+| Off       | Off    | Off    | 0     | All off
+
+## Implementation Notes
+
+In order for the receiver to respond, the RTS bit must be set on the wire.
+Setting this bit requires a 5-wire cable. I have some RS232 to 3.5 mm cables
+which aren't usable with Yamahas.
+
+Linux appears to automatically set the RTS bit upon opening the serial port,
+thus setting it explicitly may not be needed.
+
+To monitor serial communications under Linux, I used
+[slsnif](https://github.com/aeruder/slsnif) which I found via
+[this summary of serial port monitoring tools](https://serverfault.com/questions/112957/sniff-serial-port-on-linux).
+
+The receiver is very frequently not responding to the "ready" command.
+The documentation mentions retrying this command but in my experience the
+first time this command is sent to a RX-V1500 which is in standby it is
+*always* igored.
+
+I have RX-V1500 and RX-V2500, however I couldn't locate RS232 protocol manuals
+for these receivers. I am primarily using RX-V1700/RX-V2700 manual with some
+references to RX-V1000/RX-V3000 manual. The commands are mostly or completely
+identical, with RX-V1700/RX-V2700 manual describing most or all of what
+RX-V1500/RX-V2500 support, but the status responses are very different.
+For my RX-V1500/RX-V2500 I had to reverse-engineer the status responses, and
+because of this they only have a limited number of fields decoded.
+
+Volume level is set and reported as follows: 0 means muting is active,
+otherwise the minimum level for the zone is 39 and each step in the level is
+the next integer value up. For the main zone on RX-V1500/RX-V2500, the volume
+is adjusted in 0.5 dB increments from -80 dB to 14.5 dB, giving the integer
+values the range of 39-228. For zones 2 and 3 the volume is adjusted in whole
+dB increments from -33 dB to 0 dB, giving the integer range of 39-72.
+
+While testing with Python, I ran into [this issue](https://bugs.python.org/issue20074) -
+to open a TTY in Python, buffering must be disabled.
+
+See [here](https://www.avsforum.com/threads/enhancing-yamaha-avrs-via-rs-232.1066484/)
+for more Yamaha-related software.
+
+## Other Libraries
+
+Yamaha RS232/serial protocol:
+
+- [YRXV1500-MQTT](https://github.com/FireFrei/yrxv1500-mqtt)
+- [YamahaController](https://github.com/mrworf/yamahacontroller)
+- [Homie ESP8266 Yamaha RX-Vxxxx Control]https://github.com/memphi2/homie-yamaha-rs232)
+
+Serial port communication in Ruby:
+
+- [rubyserial](https://github.com/hybridgroup/rubyserial)
+- [Ruby/SerialPort](https://github.com/hparra/ruby-serialport)
+
+## Helpful Links
+
+- [Serial port programming in Ruby](https://www.thegeekdiary.com/serial-port-programming-reading-writing-status-of-control-lines-dtr-rts-cts-dsr/)

data/bin/yamaha

@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+begin
+  require 'yamaha'
+rescue LoadError
+  $: << File.join(File.dirname(__FILE__), '../lib')
+  require 'yamaha'
+end
+require 'optparse'
+require 'logger'
+require 'pp'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: yamaha [-d device] command arg..."
+
+  opts.on("-d", "--device DEVICE", "TTY to use (default autodetect)") do |v|
+    options[:device] = v
+  end
+end.parse!
+
+logger = Logger.new(STDERR)
+client = Yamaha::Client.new(options[:device], logger: logger)
+
+cmd = ARGV.shift
+unless cmd
+  raise ArgumentError, "No command given"
+end
+
+def parse_on_off(value)
+  case value&.downcase
+  when '1', 'on', 'yes', 'true'
+    true
+  when '0', 'off', 'no', 'value'
+    false
+  else
+    raise ArgumentError, "Invalid on/off value: #{value}"
+  end
+end
+
+case cmd
+when 'detect'
+  device = Yamaha::Client.detect_device(*ARGV, logger: logger)
+  if device
+    puts device
+    exit 0
+  else
+    STDERR.puts("Yamaha receiver not found")
+    exit 3
+  end
+when 'power'
+  which = ARGV.shift&.downcase
+  if %w(main zone2 zone3).include?(which)
+    method = "set_#{which}_power"
+    state = parse_on_off(ARGV.shift)
+  else
+    method = 'set_power'
+    state = parse_on_off(which)
+  end
+  client.public_send(method, state)
+when 'volume'
+  which = ARGV.shift
+  if %w(main zone2 zone3).include?(which)
+    prefix = "set_#{which}"
+    value = ARGV.shift
+  else
+    prefix = 'set_main'
+    value = which
+  end
+  if %w(. -).include?(value)
+    method = "#{prefix}_mute"
+    value = true
+  else
+    method = "#{prefix}_volume_db"
+    if value[0] == ','
+      value = value[1..]
+    end
+    value = Float(value)
+  end
+  client.public_send(method, value)
+  p client.get_main_volume_text
+  p client.get_zone2_volume_text
+  p client.get_zone3_volume_text
+when 'input'
+  which = ARGV.shift&.downcase
+  if %w(main zone2 zone3).include?(which)
+    method = "set_#{which}_input"
+    input = ARGV.shift
+  else
+    method = 'set_main_input'
+    input = which
+  end
+  client.public_send(method, input)
+when 'program'
+  value = ARGV.shift.downcase
+  client.set_program(value)
+when 'pure-direct'
+  state = parse_on_off(ARGV.shift)
+  client.set_pure_direct(state)
+when 'status'
+  pp client.last_status
+when 'status_string'
+  puts client.last_status_string
+when 'test'
+  client.set_power(false)
+  [true, false].each do |main_state|
+    [true, false].each do |zone2_state|
+      [true, false].each do |zone3_state|
+        client.set_main_power(main_state)
+        client.set_zone2_power(zone2_state)
+        client.set_zone3_power(zone3_state)
+        puts "#{main_state ?1:0} #{zone2_state ?1:0} #{zone3_state ?1:0} #{client.status[:power]}"
+      end
+    end
+  end
+else
+  raise ArgumentError, "Unknown command: #{cmd}"
+end

data/lib/yamaha/backend/ffi.rb

@@ -0,0 +1,107 @@
+require 'forwardable'
+require 'ffi'
+
+module Yamaha
+  module Backend
+    module FFIBackend
+
+      class Device
+        extend Forwardable
+
+        def initialize(device, logger: nil)
+          @logger = logger
+
+          if @f
+            yield
+          else
+            logger&.debug("Opening device #{device}")
+            File.open(device, 'r+') do |f|
+              unless f.isatty
+                raise BadDevice, "#{device} is not a TTY"
+              end
+              @f = f
+              set_rts
+
+              if IO.select([f], nil, nil, 0)
+                logger&.warn("Serial device readable without having been written to - concurrent access?")
+              end
+
+              tries = 0
+              begin
+                do_status
+              rescue Timeout::Error
+                tries += 1
+                if tries < 5
+                  logger&.warn("Timeout handshaking with the receiver - will retry")
+                  retry
+                else
+                  raise
+                end
+              end
+              yield.tap do
+                @f = nil
+              end
+            end
+          end
+        rescue IOError => e
+          if @f
+            logger&.warn("#{e.class}: #{e} while operating, closing the device")
+            @f.close
+            raise
+          end
+        end
+
+        attr_reader :logger
+        def_delegators :@f, :close
+
+        def set_rts
+          ptr = IntPtr.new
+          C.ioctl_p(@f.fileno, TIOCMGET, ptr)
+          if logger&.level <= Logger::DEBUG
+            flags = []
+            %w(DTR RTS CTS).each do |bit|
+              if ptr[:value] & self.class.const_get("TIOCM_#{bit}") > 0
+                flags << bit
+              end
+            end
+            if flags.empty?
+              flags = ['(none)']
+            end
+            logger&.debug("Initial flags: #{flags.join(' ')}")
+          end
+          unless ptr[:value] & TIOCM_RTS
+            logger&.debug("Setting RTS on #{device}")
+            ptr[:value] |= TIOCM_RTS
+            C.ioctl_p(@f.fileno, TIOCMSET, ptr)
+          end
+        end
+
+        private
+
+        class IntPtr < FFI::Struct
+          layout :value, :int
+        end
+
+        module C
+          extend FFI::Library
+          ffi_lib 'c'
+
+          # Ruby's ioctl doesn't support all of C ioctl interface,
+          # in particular returning integer values that we need.
+          # See https://stackoverflow.com/questions/1446806/getting-essid-via-ioctl-in-ruby.
+          attach_function :ioctl, [:int, :int, :pointer], :int
+          class << self
+            alias :ioctl_p :ioctl
+          end
+          remove_method :ioctl
+        end
+
+        TIOCMGET = 0x5415
+        TIOCMSET = 0x5418
+        TIOCM_DTR = 0x002
+        TIOCM_RTS = 0x004
+        TIOCM_CTS = 0x020
+      end
+    end
+  end
+end

data/lib/yamaha/backend/serial_port.rb

@@ -0,0 +1,24 @@
+require 'forwardable'
+require 'serialport'
+
+module Yamaha
+  module Backend
+    module SerialPortBackend
+
+      class Device
+        extend Forwardable
+
+        def initialize(device, logger: nil)
+          @logger = logger
+          @io = SerialPort.open(device)
+        end
+
+        attr_reader :device
+
+        attr_reader :io
+
+        def_delegators :io, :close, :sysread, :syswrite
+      end
+    end
+  end
+end

data/lib/yamaha/client.rb

@@ -0,0 +1,526 @@
+# frozen_string_literal: true
+
+require 'timeout'
+require 'yamaha/backend/serial_port'
+
+module Yamaha
+
+  class Error < StandardError; end
+  class BadDevice < Error; end
+  class BadStatus < Error; end
+  class InvalidCommand < Error; end
+  class NotApplicable < Error; end
+  class UnexpectedResponse < Error; end
+  class CommunicationTimeout < Error; end
+
+  RS232_TIMEOUT = 9
+  DEFAULT_DEVICE_GLOB = '/dev/ttyUSB*'
+
+  class Client
+    def self.detect_device(*patterns, logger: nil)
+      if patterns.empty?
+        patterns = [DEFAULT_DEVICE_GLOB]
+      end
+      devices = patterns.map do |pattern|
+        Dir.glob(pattern)
+      end.flatten.uniq
+      found = nil
+      threads = devices.map do |device|
+        Thread.new do
+          Timeout.timeout(RS232_TIMEOUT) do
+            logger&.debug("Trying #{device}")
+            new(device, logger: logger).status
+            logger&.debug("Found receiver at #{device}")
+            found = device
+          end
+        end
+      end
+      threads.map(&:join)
+      found
+    end
+
+    def initialize(device = nil, logger: nil)
+      @logger = logger
+
+      if device.nil?
+        device = Dir[DEFAULT_DEVICE_GLOB].sort.first
+        if device
+          logger&.info("Using #{device} as TTY device")
+        end
+      end
+
+      unless device
+        raise ArgumentError, "No device specified and device could not be detected automatically"
+      end
+
+      @device = device
+
+      if block_given?
+        open_device
+        begin
+          yield self
+        ensure
+          close
+        end
+      end
+    end
+
+    attr_reader :device
+    attr_accessor :logger
+
+    def last_status
+      unless @status
+        open_device do
+        end
+      end
+      @status.dup
+    end
+
+    def last_status_string
+      unless @status_string
+        open_device do
+        end
+      end
+      @status_string.dup
+    end
+
+    def status
+      do_status
+      last_status
+    end
+
+    def set_power(state)
+      remote_command("7A1#{state ? 'D' : 'E'}")
+    end
+
+    def set_main_power(state)
+      remote_command("7E7#{state ? 'E' : 'F'}")
+    end
+
+    def set_zone2_power(state)
+      remote_command("7EB#{state ? 'A' : 'B'}")
+    end
+
+    def set_zone3_power(state)
+      remote_command("7AE#{state ? 'D' : 'E'}")
+    end
+
+    def set_main_volume(value)
+      system_command("30#{'%02x' % value}")
+    end
+
+    def set_main_volume_db(volume)
+      value = Integer((volume + 80) * 2 + 39)
+      set_main_volume(value)
+    end
+
+    def set_zone2_volume(value)
+      system_command("31#{'%02x' % value}")
+    end
+
+    def set_zone2_volume_db(volume)
+      value = Integer(volume + 33 + 39)
+      set_zone2_volume(value)
+    end
+
+    def zone2_volume_up
+      remote_command('7ADA')
+    end
+
+    def zone2_volume_down
+      remote_command('7ADB')
+    end
+
+    def set_zone3_volume(volume)
+      remote_command("234#{'%02x' % value}")
+    end
+
+    def zone3_volume_up
+      remote_command('7AFD')
+    end
+
+    def zone3_volume_down
+      remote_command('7AFE')
+    end
+
+    def set_subwoofer_level(level)
+      dispatch("#{STX}249#{'%02x' % level}#{ETX}")
+    end
+
+    def get_main_volume_text
+      extract_text(system_command("2001"))[3...].strip
+    end
+
+    def get_zone2_volume_text
+      extract_text(system_command("2002"))[3...].strip
+    end
+
+    def get_zone3_volume_text
+      extract_text(system_command("2005"))[3...].strip
+    end
+
+    def set_pure_direct(state)
+      dispatch("#{STX}07E8#{state ? '0' : '2'}#{ETX}")
+    end
+
+    PROGRAM_SET = {
+      'munich' => 'E1',
+      'vienna' => 'E5',
+      'amsterdam' => 'E6',
+      'freiburg' => 'E8',
+      'chamber' => 'AF',
+      'village_vanguard' => 'EB',
+      'warehouse_loft' => 'EE',
+      'cellar_club' => 'CD',
+      'the_bottom_line' => 'EC',
+      'the_roxy_theatre' => 'ED',
+      'disco' => 'F0',
+      'game' => 'F2',
+      '7ch_stereo' => 'FF',
+      '2ch_stereo' => 'C0',
+      'sports' => 'F8',
+      'action_game' => 'F2',
+      'roleplaying_game' => 'CE',
+      'music_video' => 'F3',
+      'recital_opera' => 'F5',
+      'standard' => 'FE',
+      'spectacle' => 'F9',
+      'sci-fi' => 'FA',
+      'adventure' => 'FB',
+      'drama' => 'FC',
+      'mono_movie' => 'F7',
+      'surround_decode' => 'FD',
+      'thx_cinema' => 'C2',
+      'thx_music' => 'C3',
+      'thx_game' => 'C8',
+    }.freeze
+
+    def set_program(value)
+      program_code = PROGRAM_SET.fetch(value.downcase.gsub(/[^a-z]/, '_'))
+      remote_command("7E#{program_code}")
+    end
+
+    MAIN_INPUTS_SET = {
+      'phono' => '14',
+      'cd' => '15',
+      'tuner' => '16',
+      'cd_r' => '19',
+      'md_tape' => '18',
+      'dvd' => 'C1',
+      'dtv' => '54',
+      'cbl_sat' => 'C0',
+      'vcr1' => '0F',
+      'dvr_vcr2' => '13',
+      'v_aux_dock' => '55',
+      'multi_ch' => '87',
+      'xm' => 'B4',
+    }.freeze
+
+    def set_main_input(source)
+      source_code = MAIN_INPUTS_SET.fetch(source.downcase.gsub(/[^a-z]/, '_'))
+      remote_command("7A#{source_code}")
+    end
+
+    ZONE2_INPUTS_SET = {
+      'phono' => 'D0',
+      'cd' => 'D1',
+      'tuner' => 'D2',
+      'cd_r' => 'D4',
+      'md_tape' => 'D3',
+      'dvd' => 'CD',
+      'dtv' => 'D9',
+      'cbl_sat' => 'CC',
+      'vcr1' => 'D6',
+      'dvr_vcr2' => 'D7',
+      'v_aux_dock' => 'D8',
+      'xm' => 'B8',
+    }.freeze
+
+    def set_zone2_input(source)
+      source_code = ZONE2_INPUTS_SET.fetch(source.downcase.gsub(/[^a-z]/, '_'))
+      remote_command("7A#{source_code}")
+    end
+
+    ZONE3_INPUTS_SET = {
+      'phono' => 'F1',
+      'cd' => 'F2',
+      'tuner' => 'F3',
+      'cd_r' => 'F5',
+      'md_tape' => 'F4',
+      'dvd' => 'FC',
+      'dtv' => 'F6',
+      'cbl_sat' => 'F7',
+      'vcr1' => 'F9',
+      'dvr_vcr2' => 'FA',
+      'v_aux_dock' => 'F0',
+      'xm' => 'B9',
+    }.freeze
+
+    def set_zone3_input(source)
+      source_code = ZONE3_INPUTS_SET.fetch(source.downcase.gsub(/[^a-z]/, '_'))
+      remote_command("7A#{source_code}")
+    end
+
+    private
+
+    def open_device
+      @f = Backend::SerialPortBackend::Device.new(device, logger: logger)
+
+      tries = 0
+      begin
+        do_status
+      rescue CommunicationTimeout
+        tries += 1
+        if tries < 5
+          logger&.warn("Timeout handshaking with the receiver - will retry")
+          retry
+        else
+          raise
+        end
+      end
+
+      yield.tap do
+        @f.close
+      end
+    end
+
+    # ASCII table: https://www.asciitable.com/
+    DC1 = +?\x11
+    DC2 = +?\x12
+    ETX = +?\x03
+    STX = +?\x02
+    DEL = +?\x7f
+
+    STATUS_REQ = -"#{DC1}001#{ETX}"
+
+    ZERO_ORD = '0'.ord
+
+    def dispatch(cmd)
+      open_device do
+        do_dispatch(cmd)
+      end
+    end
+
+    def do_dispatch(cmd)
+      @f.syswrite(cmd.encode('ascii'))
+      read_response
+    end
+
+    def read_response
+      resp = +''
+      Timeout.timeout(2, CommunicationTimeout) do
+        loop do
+          ch = @f.sysread(1)
+          if ch
+            resp << ch
+            break if ch == ETX
+          else
+            sleep 0.1
+          end
+        end
+      end
+      resp
+    end
+
+    MAIN_INPUTS_GET = {
+      '0' => 'PHONO',
+      '1' => 'CD',
+      '2' => 'TUNER',
+      '3' => 'CD-R',
+      '4' => 'MD/TAPE',
+      '5' => 'DVD',
+      '6' => 'DTV',
+      '7' => 'CBL/SAT',
+      '8' => 'SAT',
+      '9' => 'VCR1',
+      'A' => 'DVR/VCR2',
+      'B' => 'VCR3/DVR',
+      'C' => 'V-AUX/DOCK',
+      'D' => 'NET/USB',
+      'E' => 'XM',
+    }.freeze
+
+    AUDIO_SELECT_GET = {
+      '0' => 'Auto', # Confirmed RX-V1500
+      '2' => 'DTS', # Confirmed RX-V1500
+      '3' => 'Coax / Opt', # Unconfirmed
+      '4' => 'Analog', # Confirmed RX-V1500
+      '5' => 'Analog Only', # Unconfirmed
+      '8' => 'HDMI', # Unconfirmed
+    }.freeze
+
+    NIGHT_GET = {
+      '0' => 'Off',
+      '1' => 'Cinema',
+      '2' => 'Music',
+    }.freeze
+
+    SLEEP_GET = {
+      '0' => 120,
+      '1' => 90,
+      '2' => 60,
+      '3' => 30,
+      '4' => nil,
+    }.freeze
+
+    PROGRAM_GET = {
+      '00' => 'Munich',
+      '01' => 'Hall B',
+      '02' => 'Hall C',
+      '04' => 'Hall D',
+      '05' => 'Vienna',
+      '06' => 'Live Concert',
+      '07' => 'Hall in Amsterdam',
+      '08' => 'Tokyo',
+      '09' => 'Freiburg',
+      '0A' => 'Royaumont',
+      '0B' => 'Chamber',
+      '0C' => 'Village Gate',
+      '0D' => 'Village Vanguard',
+      '0E' => 'The Bottom Line',
+      '0F' => 'Cellar Club',
+      '10' => 'The Roxy Theater',
+      '11' => 'Warehouse Loft',
+      '12' => 'Arena',
+      '14' => 'Disco',
+      '15' => 'Party',
+      '17' => '7ch Stereo',
+      '18' => 'Music Video',
+      '19' => 'DJ',
+      '1C' => 'Recital/Opera',
+      '1D' => 'Pavilion',
+      '1E' => 'Action Gamae',
+      '1F' => 'Role Playing Game',
+      '20' => 'Mono Movie',
+      '21' => 'Sports',
+      '24' => 'Spectacle',
+      '25' => 'Sci-Fi',
+      '28' => 'Adventure',
+      '29' => 'Drama',
+      '2C' => 'Surround Decode',
+      '2D' => 'Standard',
+      '30' => 'PLII Movie',
+      '31' => 'PLII Music',
+      '32' => 'Neo:6 Movie',
+      '33' => 'Neo:6 Music',
+      '34' => '2ch Stereo',
+      '35' => 'Direct Stereo',
+      '36' => 'THX Cinema',
+      '37' => 'THX Music',
+      '3C' => 'THX Game',
+      '40' => 'Enhancer 2ch Low',
+      '41' => 'Enhancer 2ch High',
+      '42' => 'Enhancer 7ch Low',
+      '43' => 'Enhancer 7ch Higgh',
+      '80' => 'Straight',
+    }.freeze
+
+    def do_status
+      resp = nil
+      loop do
+        resp = do_dispatch(STATUS_REQ)
+        again = false
+        while @f && IO.select([@f.io], nil, nil, 0)
+          logger&.warn("Serial device readable after completely reading status response - concurrent access?")
+          read_response
+          again = true
+        end
+        break unless again
+      end
+      payload = resp[1...-1]
+      @model_code = payload[0..4]
+      @version = payload[5]
+      length = payload[6..7].to_i(16)
+      p payload
+      data = payload[8...-2]
+      if data.length != length
+        raise BadStatus, "Broken status response: expected #{length} bytes, got #{data.length} bytes; concurrent operation on device?"
+      end
+      unless data.start_with?('@E01900')
+        raise BadStatus, "Broken status response: expected to start with @E01900, actual #{data[0..6]}"
+      end
+      puts data, data.length
+      p payload
+      @status_string = data
+      @status = {
+        # RX-V1500: model R0177
+        model_code: @model_code,
+        firmware_version: @version,
+        system_status: data[7].ord - ZERO_ORD,
+        power: power = data[8].ord - ZERO_ORD,
+        main_power: [1, 4, 5, 2].include?(power),
+        zone2_power: [1, 4, 3, 6].include?(power),
+        zone3_power: [1, 5, 3, 7].include?(power),
+      }
+      if data.length > 9
+        @status.update(
+          input: input = data[9],
+          input_name: MAIN_INPUTS_GET.fetch(input),
+          multi_ch_input: data[10] == '1',
+          audio_select: audio_select = data[11],
+          audio_select_name: AUDIO_SELECT_GET.fetch(audio_select),
+          mute: data[12] == '1',
+          # Volume values (0.5 dB increment):
+          # mute: 0
+          # -80.0 dB (min): 39
+          # 0 dB: 199
+          # +14.5 dB (max): 228
+          # Zone2 volume values (1 dB increment):
+          # mute: 0
+          # -33 dB (min): 39
+          # 0 dB (max): 72
+          main_volume: volume = data[15..16].to_i(16),
+          main_volume_db: int_to_half_db(volume),
+          zone2_volume: zone2_volume = data[17..18].to_i(16),
+          zone2_volume_db: int_to_full_db(zone2_volume),
+          zone3_volume: zone3_volume = data[129..130].to_i(16),
+          zone3_volume_db: int_to_full_db(zone3_volume),
+          program: program = data[19..20],
+          program_name: PROGRAM_GET.fetch(program),
+          # true: straight; false: effect
+          effect: data[21] == '1',
+          #extended_surround: data[22],
+          #short_message: data[23],
+          sleep: SLEEP_GET.fetch(data[24]),
+          night: night = data[27],
+          night_name: NIGHT_GET.fetch(night),
+          pure_direct: data[28] == '1',
+          speaker_a: data[29] == '1',
+          speaker_b: data[30] == '1',
+          format: data[31..32],
+          sample_rate: data[33..34],
+        )
+      end
+      @status
+    end
+
+    def remote_command(cmd)
+      dispatch("#{STX}0#{cmd}#{ETX}")
+    end
+
+    def system_command(cmd)
+      dispatch("#{STX}2#{cmd}#{ETX}")
+    end
+
+    def extract_text(resp)
+      # TODO: assert resp[0] == DC1, resp[-1] == ETX
+      resp[0...-1]
+    end
+
+    def int_to_half_db(value)
+      if value == 0
+        :mute
+      else
+        (value - 39) / 2.0 - 80
+      end
+    end
+
+    def int_to_full_db(value)
+      if value == 0
+        :mute
+      else
+        (value - 39) - 33
+      end
+    end
+  end
+end

data/lib/yamaha/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Yamaha
+  VERSION = -'0.0.2'
+end

data/lib/yamaha.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'yamaha/version'
+require 'yamaha/client'

data/yamaha.gemspec

@@ -0,0 +1,17 @@
+# coding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name          = "yamaha"
+  spec.version       = '0.0.2'
+  spec.authors       = ['Oleg Pudeyev']
+  spec.email         = ['code@olegp.name']
+  spec.summary       = %q{Yamaha Receiver Serial Control Interface}
+  spec.description   = %q{Library for controlling Yamaha amplifiers via the serial port}
+  spec.homepage      = "https://github.com/p/yamaha-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: yamaha
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Oleg Pudeyev
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-11-02 00:00:00.000000000 Z
+dependencies: []
+description: Library for controlling Yamaha amplifiers via the serial port
+email:
+- code@olegp.name
+executables:
+- yamaha
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/yamaha
+- lib/yamaha.rb
+- lib/yamaha/backend/ffi.rb
+- lib/yamaha/backend/serial_port.rb
+- lib/yamaha/client.rb
+- lib/yamaha/version.rb
+- yamaha.gemspec
+homepage: https://github.com/p/yamaha-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.15
+signing_key:
+specification_version: 4
+summary: Yamaha Receiver Serial Control Interface
+test_files: []