seriamp 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cd8d27d7818b801b6734b046fcc3682b1322bc03cfaa8d2472f4963d5974f7d5
+  data.tar.gz: 917a111090ce967b0c28684f60fc0ccf8dca627c0c5d6ae1699b97746be69afc
+SHA512:
+  metadata.gz: 166e4cc102b91987bcb244aee644b682757609ad19ea42eafb88216f09295b87344a7906d925ff0479fe58b4db477691404bcfb7211d9bab7b29d29fe41555f2
+  data.tar.gz: 4e4aac13144356caeb92bf05da4e50181f1f83613e5ed1bb857fe91c1562d6d352b81c9e9eb051f6f8f50cc348f4bb61f0e8f04887880480dbc6e8c19be513de

data/.gitignore

@@ -0,0 +1,3 @@
+.yardoc
+*.gem
+/doc

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,75 @@
+# 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 is 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/sonamp

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'seriamp/sonamp/cmd'
+rescue LoadError
+  $: << File.join(File.dirname(__FILE__), '../lib')
+  require 'seriamp/sonamp/cmd'
+end
+
+Seriamp::Sonamp::Cmd.new(ARGV).run

data/bin/sonamp-web

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'seriamp/sonamp/app'
+rescue LoadError
+  $: << File.join(File.dirname(__FILE__), '../lib')
+  require 'seriamp/sonamp/app'
+end
+require 'optparse'
+require 'logger'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: sonamp-web [-d device] [-- rackup-options...]"
+
+  opts.on("-d", "--device DEVICE", "TTY to use (default autodetect)") do |v|
+    options[:device] = v
+  end
+
+  opts.separator ''
+  opts.separator 'To see rackup options: sonamp-web -- -h'
+end.parse!
+
+logger = Logger.new(STDERR)
+
+#Sonamp::App.set :device, options[:device]
+#Sonamp::App.set :logger, logger
+Seriamp::Sonamp::App.set :client, Sonamp::Client.new(options[:device], logger: logger)
+
+options = Rack::Server::Options.new.parse!(ARGV)
+Rack::Server.start(options.merge(app: Sonamp::App))

data/bin/yamaha

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+begin
+  require 'seriamp/yamaha/cmd'
+rescue LoadError
+  $: << File.join(File.dirname(__FILE__), '../lib')
+  require 'seriamp/yamaha/cmd'
+end
+
+Seriamp::Yamaha::Cmd.new(ARGV).run

data/bin/yamaha-web

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'seriamp/yamaha/app'
+rescue LoadError
+  $: << File.join(File.dirname(__FILE__), '../lib')
+  require 'seriamp/yamaha/app'
+end
+require 'optparse'
+require 'logger'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: yamaha-web [-d device] [-- rackup-options...]"
+
+  opts.on("-d", "--device DEVICE", "TTY to use (default autodetect)") do |v|
+    options[:device] = v
+  end
+
+  opts.separator ''
+  opts.separator 'To see rackup options: yamaha-web -- -h'
+end.parse!
+
+logger = Logger.new(STDERR)
+
+#Yamaha::App.set :device, options[:device]
+#Yamaha::App.set :logger, logger
+Seriamp::Yamaha::App.set :client, Yamaha::Client.new(options[:device], logger: logger)
+
+options = Rack::Server::Options.new.parse!(ARGV)
+Rack::Server.start(options.merge(app: Yamaha::App))

data/lib/seriamp/backend/ffi.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'ffi'
+
+module Seriamp
+  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/seriamp/backend/serial_port.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'serialport'
+
+module Seriamp
+  module Backend
+    module SerialPortBackend
+
+      class Device
+        extend Forwardable
+
+        def initialize(device, logger: nil)
+          @logger = logger
+          @io = SerialPort.open(device)
+
+          if block_given?
+            begin
+              yield self
+            ensure
+              close rescue nil
+            end
+          end
+        end
+
+        attr_reader :device
+
+        attr_reader :io
+
+        def_delegators :io, :close, :sysread, :syswrite
+      end
+    end
+  end
+end

data/lib/seriamp/detect.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'timeout'
+require 'seriamp/error'
+
+module Seriamp
+
+  DEFAULT_DEVICE_GLOB = '/dev/ttyUSB*'
+
+  module_function def detect_device(mod, *patterns, logger: nil)
+    if patterns.empty?
+      patterns = [DEFAULT_DEVICE_GLOB]
+    end
+    devices = patterns.map do |pattern|
+      Dir.glob(pattern)
+    end.flatten.uniq
+    queue = Queue.new
+    timeout = mod.const_get(:RS232_TIMEOUT)
+    client_cls = mod.const_get(:Client)
+    threads = devices.map do |device|
+      Thread.new do
+        Timeout.timeout(timeout * 2, CommunicationTimeout) do
+          logger&.debug("Trying #{device}")
+          client_cls.new(device: device, logger: logger).present?
+          logger&.debug("Found #{mod} device at #{device}")
+          queue << device
+        end
+      rescue CommunicationTimeout, IOError, SystemCallError => exc
+        logger&.debug("Failed on #{mod} #{device}: #{exc.class}: #{exc}")
+      end
+    end
+    wait_thread = Thread.new do
+      threads.each do |thread|
+        # Unhandled exceptions raised in threads are reraised by the join method
+        thread.join rescue nil
+      end
+      queue << nil
+    end
+    queue.shift.tap do
+      threads.map(&:kill)
+      wait_thread.kill
+    end
+  end
+end

data/lib/seriamp/error.rb

@@ -0,0 +1,10 @@
+module Seriamp
+  class Error < StandardError; end
+  class NoDevice < Error; end
+  class BadDevice < Error; end
+  class InvalidCommand < Error; end
+  class NotApplicable < Error; end
+  class UnexpectedResponse < Error; end
+  class HandshakeFailure < UnexpectedResponse; end
+  class CommunicationTimeout < Error; end
+end

data/lib/seriamp/sonamp/app.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'sinatra/base'
+require 'seriamp/utils'
+require 'seriamp/sonamp/client'
+
+module Seriamp
+  module Sonamp
+    class App < Sinatra::Base
+
+      set :device, nil
+      set :logger, nil
+      set :client, nil
+
+      get '/power' do
+        render_json(client.get_zone_power)
+      end
+
+      get '/zone/:zone/power' do |zone|
+        render_json(client.get_zone_power(zone.to_i))
+      end
+
+      put '/zone/:zone/power' do |zone|
+        state = Utils.parse_on_off(request.body.read)
+        client.set_zone_power(zone.to_i, state)
+      end
+
+      get '/zone/:zone/volume' do |zone|
+        render_json(client.get_zone_volume(zone.to_i))
+      end
+
+      put '/zone/:zone/volume' do |zone|
+        volume = request.body.read.to_i
+        client.set_zone_volume(zone.to_i, volume)
+      end
+
+      get '/channel/:channel/volume' do |channel|
+        render_json(client.get_channel_volume(channel.to_i))
+      end
+
+      put '/channel/:channel/volume' do |channel|
+        volume = request.body.read.to_i
+        client.set_channel_volume(channel.to_i, volume)
+      end
+
+      post '/' do
+      end
+
+      private
+
+      def client
+        settings.client || begin
+          @client ||= Sonamp::Client.new(settings.device, logger: settings.logger)
+        end
+      end
+
+      def render_json(data)
+        data.to_json
+      end
+    end
+  end
+end