seriamp 0.1.2

data/lib/seriamp/sonamp/client.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require 'timeout'
+require 'seriamp/error'
+require 'seriamp/backend/serial_port'
+
+module Seriamp
+  module Sonamp
+
+    RS232_TIMEOUT = 3
+
+    class Client
+      def initialize(device: nil, glob: nil, logger: nil)
+        @logger = logger
+
+        @device = device
+        @detect_device = device.nil?
+        @glob = glob
+      end
+
+      attr_reader :device
+      attr_reader :glob
+      attr_reader :logger
+
+      def detect_device?
+        @detect_device
+      end
+
+      def present?
+        get_zone_power(1)
+        true
+      end
+
+      def get_zone_power(zone = nil)
+        get_zone_state('P', zone)
+      end
+
+      def set_zone_power(zone, state)
+        if zone < 1 || zone > 4
+          raise ArgumentError, "Zone must be between 1 and 4: #{zone}"
+        end
+        cmd = ":P#{zone}#{state ? 1 : 0}"
+        expected = cmd[1...cmd.length]
+        dispatch_assert(cmd, expected)
+      end
+
+      def power_off
+        1.upto(4).each do |zone|
+          set_zone_power(zone, false)
+        end
+      end
+
+      def get_zone_volume(zone = nil)
+        get_zone_value('V', zone)
+      end
+
+      def set_zone_volume(zone, volume)
+        if volume < 0 || volume > 100
+          raise ArgumentError, "Volume must be between 0 and 100: #{volume}"
+        end
+        set_zone_value('V', zone, volume)
+      end
+
+      def set_zone_mute(zone, state)
+        set_zone_value('M', zone, state ? 1 : 0)
+      end
+
+      def get_channel_volume(channel = nil)
+        get_channel_value('VC', channel)
+      end
+
+      def set_channel_volume(channel, volume)
+        if channel < 1 || channel > 8
+          raise ArgumentError, "Channel must be between 1 and 4: #{channel}"
+        end
+        if volume < 0 || volume > 100
+          raise ArgumentError, "Volume must be between 0 and 100: #{volume}"
+        end
+        cmd = ":VC#{channel}#{volume}"
+        expected = cmd[1...cmd.length]
+        dispatch_assert(cmd, expected)
+      end
+
+      def set_channel_mute(channel, state)
+        set_channel_value('MC', channel, state ? 1 : 0)
+      end
+
+      def get_zone_mute(zone = nil)
+        get_zone_state('M', zone)
+      end
+
+      def get_channel_mute(channel = nil)
+        get_channel_state('MC', channel)
+      end
+
+      def get_channel_front_panel_level(channel = nil)
+        get_channel_value('TVL', channel)
+      end
+
+      def get_zone_fault(zone = nil)
+        get_zone_state('FP', zone)
+      end
+
+      def get_bbe(zone = nil)
+        get_zone_state('BP', zone)
+      end
+
+      def get_bbe_high_boost(zone = nil)
+        get_zone_state('BH', zone)
+      end
+
+      def get_bbe_low_boost(zone = nil)
+        get_zone_state('BL', zone)
+      end
+
+      def get_auto_trigger_input(zone = nil)
+        get_zone_state('ATI', zone)
+      end
+
+      def get_voltage_trigger_input(zone = nil)
+        get_zone_state('VTI', zone)
+      end
+
+      def get_firmware_version
+        global_query('VER')
+      end
+
+      def get_temperature
+        Integer(global_query('TP'))
+      end
+
+      def status
+        # Reusing the opened device file makes :VTIG? fail even with a delay
+        # in front.
+        #open_device do
+          {
+            firmware_version: get_firmware_version,
+            temperature: get_temperature,
+            zone_power: get_zone_power,
+            zone_fault: get_zone_fault,
+            zone_volume: get_zone_volume,
+            channel_volume: get_channel_volume,
+            zone_mute: get_zone_mute,
+            channel_mute: get_channel_mute,
+            bbe: get_bbe,
+            bbe_high_boost: get_bbe_high_boost,
+            bbe_low_boost: get_bbe_low_boost,
+            auto_trigger_input: get_auto_trigger_input,
+            voltage_trigger_input: get_voltage_trigger_input,
+            channel_front_panel_level: get_channel_front_panel_level,
+          }
+        #end
+      end
+
+      private
+
+      def open_device
+        if detect_device? && device.nil?
+          @device = Seriamp.detect_device(Sonamp, *glob, logger: logger)
+          if @device
+            logger&.info("Using #{device} as TTY device")
+          else
+            raise NoDevice, "No device specified and device could not be detected automatically"
+          end
+        end
+
+        if @f
+          yield
+        else
+          rv = nil
+          Backend::SerialPortBackend::Device.new(device) do |f|
+            @f = f
+            rv = yield
+            @f = nil
+          end
+          rv
+        end
+      end
+
+      def dispatch(cmd, resp_lines_count = 1)
+        open_device do
+          with_timeout do
+            @f.syswrite("#{cmd}\x0d")
+          end
+          resp = 1.upto(resp_lines_count).map do
+            read_line(@f, cmd)
+          end
+          if resp_lines_count == 1
+            resp.first
+          else
+            resp
+          end
+        end
+      end
+
+      def dispatch_assert(cmd, expected)
+        resp = dispatch(cmd)
+        if resp != expected
+          raise UnexpectedResponse, "Expected #{expected}, got #{resp}"
+        end
+      end
+
+      def extract_suffix(resp, expected_prefix)
+        unless resp[0..expected_prefix.length-1] == expected_prefix
+          raise UnexpectedResponse, "Unexpected response: expected #{expected_prefix}..., actual #{resp}"
+        end
+        resp[expected_prefix.length..]
+      end
+
+      def dispatch_extract_suffix(cmd, expected_prefix)
+        resp = dispatch(cmd)
+        extract_suffix(resp, expected_prefix)
+      end
+
+      def global_query(cmd)
+        dispatch_extract_suffix(":#{cmd}?", cmd)
+      end
+
+      def with_timeout(&block)
+        Timeout.timeout(RS232_TIMEOUT, CommunicationTimeout, &block)
+      end
+
+      def read_line(f, cmd)
+        with_timeout do
+          resp = +''
+          loop do
+            ch = f.sysread(1)
+            if ch
+              break if ch == ?\r
+              resp << ch
+            else
+              sleep 0.1
+            end
+          end
+          if resp == 'ERR'
+            raise InvalidCommand, "Invalid command: #{cmd}"
+          elsif resp == 'N/A'
+            raise NotApplicable, "Command was recognized but could not be executed - is serial control enabled on the amplifier?"
+          end
+          resp
+        end
+      end
+
+      def set_zone_value(cmd_prefix, zone, value)
+        if zone < 1 || zone > 4
+          raise ArgumentError, "Zone must be between 1 and 4: #{zone}"
+        end
+        cmd = ":#{cmd_prefix}#{zone}#{value}"
+        expected = cmd[1...cmd.length]
+        dispatch_assert(cmd, expected)
+      end
+
+      def get_zone_value(cmd_prefix, zone, boolize: false)
+        if zone
+          if zone < 1 || zone > 4
+            raise ArgumentError, "Zone must be between 1 and 4: #{zone}"
+          end
+          resp = dispatch(":#{cmd_prefix}#{zone}?")
+          typecast_value(resp[cmd_prefix.length + 1..], boolize)
+        else
+          index = 1
+          hashize_query_result(dispatch(":#{cmd_prefix}G?", 4), cmd_prefix, boolize)
+        end
+      end
+
+      def hashize_query_result(resp_lines, cmd_prefix, boolize)
+        index = 1
+        Hash[resp_lines.map do |resp|
+          value = typecast_value(extract_suffix(resp, "#{cmd_prefix}#{index}"), boolize)
+          [index, value].tap do
+            index += 1
+          end
+        end]
+      end
+
+      def get_zone_state(cmd_prefix, zone)
+        get_zone_value(cmd_prefix, zone, boolize: true)
+      end
+
+      def set_channel_value(cmd_prefix, channel, value)
+        if channel < 1 || channel > 8
+          raise ArgumentError, "Channel must be between 1 and 8: #{channel}"
+        end
+        cmd = ":#{cmd_prefix}#{channel}#{value}"
+        expected = cmd[1...cmd.length]
+        dispatch_assert(cmd, expected)
+      end
+
+      def get_channel_value(cmd_prefix, channel, boolize: false)
+        if channel
+          if channel < 1 || channel > 8
+            raise ArgumentError, "Channel must be between 1 and 8: #{channel}"
+          end
+          typecast_value(dispatch_extract_suffix(":#{cmd_prefix}#{channel}?", "#{cmd_prefix}#{channel}"), boolize)
+        else
+          index = 1
+          hashize_query_result(dispatch(":#{cmd_prefix}G?", 8), cmd_prefix, boolize)
+        end
+      end
+
+      def get_channel_state(cmd_prefix, channel)
+        get_channel_value(cmd_prefix, channel, boolize: true)
+      end
+
+      def typecast_value(value, boolize)
+        value = Integer(value)
+        if boolize
+          value = value == 1
+        end
+        value
+      end
+    end
+  end
+end

data/lib/seriamp/sonamp/cmd.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'logger'
+require 'seriamp/utils'
+require 'seriamp/detect'
+require 'seriamp/sonamp/client'
+
+module Seriamp
+  module Sonamp
+    class Cmd
+      def initialize(args)
+        args = args.dup
+
+        options = {}
+        OptionParser.new do |opts|
+          opts.banner = "Usage: sonamp [-d device] command arg..."
+
+          opts.on("-d", "--device DEVICE", "TTY to use (default autodetect)") do |v|
+            options[:device] = v
+          end
+        end.parse!(args)
+
+        @options = options
+
+        @logger = Logger.new(STDERR)
+        @client = Sonamp::Client.new(device: options[:device], logger: @logger)
+
+        @args = args
+      end
+
+      attr_reader :args
+      attr_reader :logger
+
+      def run
+        if args.any?
+          run_command(args)
+        else
+          STDIN.each_line do |line|
+            line.strip!
+            line.sub!(/#.*/, '')
+            next if line.empty?
+
+            run_command(line.strip.split(%r,\s+,))
+          end
+        end
+      end
+
+      def run_command(args)
+        cmd = args.shift
+        unless cmd
+          raise ArgumentError, "No command given"
+        end
+
+        case cmd
+        when 'detect'
+          device = Seriamp.detect_device(Sonamp, *args, logger: logger)
+          if device
+            puts device
+            exit 0
+          else
+            STDERR.puts("Sonamp amplifier not found")
+            exit 3
+          end
+        when 'off'
+          client.set_zone_power(1, false)
+          client.set_zone_power(2, false)
+          client.set_zone_power(3, false)
+          client.set_zone_power(4, false)
+        when 'power'
+          zone = args.shift.to_i
+          state = Utils.parse_on_off(ARGV.shift)
+          client.set_zone_power(zone, state)
+        when 'zvol'
+          zone = args.shift.to_i
+          volume = ARGV.shift.to_i
+          client.set_zone_volume(zone, volume)
+        when 'cvol'
+          channel = args.shift.to_i
+          volume = args.shift.to_i
+          client.set_channel_volume(channel, volume)
+        when 'zmute'
+          zone = args.shift.to_i
+          mute = ARGV.shift.to_i
+          client.set_zone_mute(zone, mute)
+        when 'cmute'
+          channel = args.shift.to_i
+          mute = args.shift.to_i
+          client.set_channel_mute(channel, mute)
+        when 'status'
+          pp client.status
+        else
+          raise ArgumentError, "Unknown command: #{cmd}"
+        end
+      end
+
+      private
+
+      attr_reader :client
+    end
+  end
+end

data/lib/seriamp/sonamp.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'seriamp/detect'
+require 'seriamp/sonamp/client'

data/lib/seriamp/utils.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Seriamp
+  module Utils
+
+    module_function def parse_on_off(value)
+      case value&.downcase
+      when '1', 'on', 'yes', 'true'
+        true
+      when '0', 'off', 'no', 'false'
+        false
+      else
+        raise ArgumentError, "Invalid on/off value: #{value}"
+      end
+    end
+  end
+end

data/lib/seriamp/version.rb

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

data/lib/seriamp/yamaha/app.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'sinatra/base'
+require 'seriamp/utils'
+require 'seriamp/yamaha/client'
+
+module Seriamp
+  module Yamaha
+    class App < Sinatra::Base
+
+      set :device, nil
+      set :logger, nil
+      set :client, nil
+
+      get '/power' do
+        render_json(client.last_status.fetch(:power) > 0)
+      end
+
+      %w(main zone2 zone3).each do |zone|
+        get "/#{zone}/power" do
+          render_json(client.last_status.fetch(:"#{zone}_power"))
+        end
+
+        put "/#{zone}/power" do
+          state = Utils.parse_on_off(request.body.read)
+          client.public_send("set_#{zone}_power", state)
+          empty_response
+        end
+
+        get '/#{zone}/volume' do
+          render_json(client.public_send("get_#{zone}_volume"))
+        end
+
+        put '/#{zone}/volume' do
+          value = Float(request.body.read)
+          client.public_send("set_#{zone}_volume_db", value)
+          empty_response
+        end
+      end
+
+      private
+
+      def client
+        settings.client || begin
+          @client ||= Yamaha::Client.new(settings.device, logger: settings.logger)
+        end
+      end
+
+      def render_json(data)
+        data.to_json
+      end
+
+      def empty_response
+        render_json({})
+      end
+    end
+  end
+end