procon_bypass_man 0.1.2

data/examples/practical/app.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'procon_bypass_man', github: 'splaspla-hacker/procon_bypass_man', branch: "edge"
+  gem 'procon_bypass_man-splatoon2', github: 'splaspla-hacker/procon_bypass_man-splatoon2', branch: "0.1.0"
+end
+
+ProconBypassMan.tap do |pbm|
+  pbm.logger = "./app.log"
+  pbm.logger.level = :debug
+end
+
+ProconBypassMan.run(setting_path: "./setting.yml")

data/examples/practical/setting.yml

@@ -0,0 +1,24 @@
+version: 1.0
+setting: |-
+  fast_return = ProconBypassMan::Splatoon2::Macro::FastReturn
+  guruguru = ProconBypassMan::Splatoon2::Mode::Guruguru
+
+  install_macro_plugin fast_return
+  install_mode_plugin guruguru
+
+  prefix_keys_for_changing_layer [:zr, :r, :zl, :l]
+
+  layer :up, mode: :manual do
+    flip :zr, if_pressed: :zr, force_neutral: :zl
+    flip :zl, if_pressed: [:y, :b, :zl]
+    flip :down, if_pressed: :down
+    macro fast_return.name, if_pressed: [:y, :b, :down]
+    remap :l, to: :zr
+  end
+  layer :right, mode: guruguru.name
+  layer :left do
+    # no-op
+  end
+  layer :down do
+    flip :zl
+  end

data/examples/simple.rb

@@ -0,0 +1,13 @@
+ProconBypassMan.run do
+  prefix_keys_for_changing_layer [:zr, :r, :zl, :l]
+
+  layer :up, mode: :manual do
+    flip :zr, if_pressed: :zr
+  end
+  layer :right
+  layer :left
+  layer :down do
+    flip :zl
+  end
+end
+

data/lib/procon_bypass_man.rb

@@ -0,0 +1,66 @@
+require "logger"
+require 'yaml'
+
+require_relative "procon_bypass_man/version"
+require_relative "procon_bypass_man/device_registry"
+require_relative "procon_bypass_man/bypass"
+require_relative "procon_bypass_man/runner"
+require_relative "procon_bypass_man/processor"
+require_relative "procon_bypass_man/procon/data"
+require_relative "procon_bypass_man/configuration"
+require_relative "procon_bypass_man/procon"
+
+STDOUT.sync = true
+Thread.abort_on_exception = true
+
+module ProconBypassMan
+  class ProConRejected < StandardError; end
+  class CouldNotLoadConfigError < StandardError; end
+  class CouldNotConnectDeviceError < StandardError; end
+
+  def self.configure(setting_path: nil, &block)
+    unless setting_path
+      logger.warn "setting_pathが未設定です。設定ファイルのライブリロードが使えません。"
+    end
+
+    if block_given?
+      ProconBypassMan::Configuration.instance.instance_eval(&block)
+    else
+      ProconBypassMan::Configuration::Loader.load(setting_path: setting_path)
+    end
+  end
+
+  def self.run(setting_path: nil, &block)
+    configure(setting_path: setting_path, &block)
+    registry = ProconBypassMan::DeviceRegistry.new
+    Runner.new(gadget: registry.gadget, procon: registry.procon).run
+  rescue CouldNotLoadConfigError
+    ProconBypassMan.logger.error "設定ファイルが不正です。設定ファイルの読み込みに失敗しました"
+    puts "設定ファイルが不正です。設定ファイルの読み込みに失敗しました"
+    exit 1
+  rescue CouldNotConnectDeviceError
+    ProconBypassMan.logger.error "デバイスと接続中です"
+    puts "デバイスと接続中です"
+    retry
+  end
+
+  def self.logger=(dev)
+    @@logger = Logger.new(dev, 5, 1024 * 1024 * 10) # 5世代まで残して, 10MBでローテーション
+  end
+
+  def self.logger
+    if defined?(@@logger)
+      @@logger
+    else
+      Logger.new(nil)
+    end
+  end
+
+  def self.reset!
+    ProconBypassMan::Procon::MacroRegistry.reset!
+    ProconBypassMan::Procon::ModeRegistry.reset!
+    ProconBypassMan::Procon.reset!
+    ProconBypassMan::Configuration.instance.reset!
+    ProconBypassMan::IOMonitor.reset!
+  end
+end

data/lib/procon_bypass_man/bypass.rb

@@ -0,0 +1,53 @@
+class ProconBypassMan::Bypass
+  attr_accessor :gadget, :procon, :monitor
+  def initialize(gadget: , procon: , monitor: )
+    self.gadget = gadget
+    self.procon = procon
+    self.monitor = monitor
+  end
+
+  # ゆっくりでいい
+  def send_gadget_to_procon!
+    monitor.record(:start_function)
+    input = nil
+    begin
+      sleep($will_interval_1_6)
+      input = self.gadget.read_nonblock(128)
+      ProconBypassMan.logger.debug { ">>> #{input.unpack("H*")}" }
+    rescue IO::EAGAINWaitReadable
+      monitor.record(:eagain_wait_readable_on_read)
+      return if $will_terminate_token
+      retry
+    end
+
+    begin
+      self.procon.write_nonblock(input)
+    rescue IO::EAGAINWaitReadable
+      monitor.record(:eagain_wait_readable_on_write)
+      return
+    end
+    monitor.record(:end_function)
+  end
+
+  def send_procon_to_gadget!
+    monitor.record(:start_function)
+    output = nil
+    begin
+      sleep($will_interval_0_0_0_5)
+      output = self.procon.read_nonblock(128)
+      ProconBypassMan.logger.debug { "<<< #{output.unpack("H*")}" }
+    rescue IO::EAGAINWaitReadable
+      monitor.record(:eagain_wait_readable_on_read)
+      return if $will_terminate_token
+      retry
+    end
+
+    begin
+      self.gadget.write_nonblock(ProconBypassMan::Processor.new(output).process)
+    rescue IO::EAGAINWaitReadable
+      monitor.record(:eagain_wait_readable_on_write)
+      return
+    end
+    monitor.record(:end_function)
+  end
+end

data/lib/procon_bypass_man/configuration.rb

@@ -0,0 +1,83 @@
+require "procon_bypass_man/configuration/validator"
+require "procon_bypass_man/configuration/loader"
+require "procon_bypass_man/configuration/layer"
+
+module ProconBypassMan
+  class Configuration
+    include Validator
+
+    attr_accessor :layers,
+      :setting_path,
+      :mode_plugins,
+      :macro_plugins,
+      :context,
+      :current_context_key
+
+    def self.instance
+      @@current_context_key ||= :main
+      @@context ||= {}
+      @@context[@@current_context_key] ||= new
+    end
+
+    def self.switch_context(key)
+      @@context[key] ||= new
+      previous_key = @@current_context_key
+      if block_given?
+        @@current_context_key = key
+        value = yield(@@context[key])
+        @@context[key].reset!
+        @@current_context_key = previous_key
+        return value
+      else
+        @@current_context_key = key
+      end
+    end
+
+    def initialize
+      reset!
+    end
+
+    MODES = [:manual]
+    def layer(direction, mode: :manual, &block)
+      unless (MODES + ProconBypassMan::Procon::ModeRegistry.plugins.keys).include?(mode)
+        raise("#{mode} mode is unknown")
+      end
+
+      layer = Layer.new(mode: mode)
+      layer.instance_eval(&block) if block_given?
+      self.layers[direction] = layer
+      self
+    end
+
+    def install_mode_plugin(klass)
+      ProconBypassMan::Procon::ModeRegistry.install_plugin(klass)
+      self
+    end
+
+    def install_macro_plugin(klass)
+      ProconBypassMan::Procon::MacroRegistry.install_plugin(klass)
+      self
+    end
+
+    def prefix_keys_for_changing_layer(buttons)
+      @prefix_keys_for_changing_layer = buttons
+      self
+    end
+
+    def prefix_keys
+      @prefix_keys_for_changing_layer
+    end
+
+    def reset!
+      @prefix_keys_for_changing_layer = []
+      self.mode_plugins = {}
+      self.macro_plugins = {}
+      self.layers = {
+        up: Layer.new,
+        down: Layer.new,
+        left: Layer.new,
+        right: Layer.new,
+      }
+    end
+  end
+end

data/lib/procon_bypass_man/configuration/layer.rb

@@ -0,0 +1,52 @@
+module ProconBypassMan
+  class Configuration
+    class Layer
+      attr_accessor :mode, :flips, :macros, :remaps
+
+      def initialize(mode: :manual, &block)
+        self.mode = mode
+        self.flips = {}
+        self.macros = {}
+        self.remaps = {}
+        instance_eval(&block) if block_given?
+      end
+
+      # @param [Symbol] button
+      def flip(button, if_pressed: false, channel: nil, force_neutral: nil)
+        case if_pressed
+        when TrueClass
+          if_pressed = [button]
+        when Symbol
+          if_pressed = [if_pressed]
+        when Array, FalseClass
+          # sono mama
+        else
+          raise "not support class"
+        end
+        hash = { if_pressed: if_pressed }
+        if channel
+          hash[:channel] = channel
+        end
+        if force_neutral
+          hash[:force_neutral] = force_neutral
+        end
+        self.flips[button] = hash
+      end
+
+      PRESET_MACROS = [:fast_return]
+      def macro(name, if_pressed: )
+        self.macros[name] = { if_pressed: if_pressed }
+      end
+
+      def remap(button, to: )
+        raise "シンボル以外は設定できません" unless to.is_a?(Symbol)
+        self.remaps[button] = to
+      end
+
+      # @return [Array]
+      def flip_buttons
+        flips
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/configuration/loader.rb

@@ -0,0 +1,44 @@
+module ProconBypassMan
+  class Configuration
+    module Loader
+      def self.load(setting_path: )
+        validation_instance = ProconBypassMan::Configuration.switch_context(:validation) do |instance|
+          begin
+            yaml = YAML.load_file(setting_path) or raise "読み込みに失敗しました"
+            instance.instance_eval(yaml["setting"])
+          rescue SyntaxError
+            instance.errors[:base] << "Rubyのシンタックスエラーです"
+            next(instance)
+          rescue Psych::SyntaxError
+            instance.errors[:base] << "yamlのシンタックスエラーです"
+            next(instance)
+          end
+          instance.valid?
+          next(instance)
+        end
+
+        if !validation_instance.errors.empty?
+          raise ProconBypassMan::CouldNotLoadConfigError, validation_instance.errors
+        end
+
+        yaml = YAML.load_file(setting_path)
+        ProconBypassMan::Configuration.instance.setting_path = setting_path
+        ProconBypassMan::Configuration.instance.reset!
+        ProconBypassMan.reset!
+
+        case yaml["version"]
+        when 1.0, nil
+          ProconBypassMan::Configuration.instance.instance_eval(yaml["setting"])
+        else
+          ProconBypassMan.logger.warn "不明なバージョンです。failoverします"
+          ProconBypassMan::Configuration.instance.instance_eval(yaml["setting"])
+        end
+        ProconBypassMan::Configuration.instance
+      end
+
+      def self.reload_setting
+        self.load(setting_path: ProconBypassMan::Configuration.instance.setting_path)
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/configuration/validator.rb

@@ -0,0 +1,26 @@
+module ProconBypassMan
+  class Configuration
+    module Validator
+      # @return [Boolean]
+      def valid?
+        @errors = Hash.new {|h,k| h[k] = [] }
+        if prefix_keys.empty?
+          @errors[:prefix_keys] ||= []
+          @errors[:prefix_keys] << "prefix_keys_for_changing_layerに値が入っていません。"
+        end
+
+        @errors.empty?
+      end
+
+      # @return [Boolean]
+      def invalid?
+        !valid?
+      end
+
+      # @return [Hash]
+      def errors
+        @errors ||= Hash.new {|h,k| h[k] = [] }
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/device_registry.rb

@@ -0,0 +1,41 @@
+class ProconBypassMan::DeviceRegistry
+  PROCON_PATH = "/dev/hidraw0"
+  PROCON2_PATH = "/dev/hidraw1"
+
+  def gadget
+    @gadget
+  end
+
+  def procon
+    @procon
+  end
+
+  def initialize
+    init_devices
+  end
+
+  # @return [void]
+  def init_devices
+    loop do
+      case
+      when File.exist?(PROCON_PATH)
+        system('echo > /sys/kernel/config/usb_gadget/procon/UDC')
+        system('ls /sys/class/udc > /sys/kernel/config/usb_gadget/procon/UDC')
+        sleep 0.5
+        @gadget = File.open('/dev/hidg0', "w+")
+        @procon = File.open(PROCON_PATH, "w+")
+        break
+      when File.exist?(PROCON2_PATH)
+        system('echo > /sys/kernel/config/usb_gadget/procon/UDC')
+        system('ls /sys/class/udc > /sys/kernel/config/usb_gadget/procon/UDC')
+        sleep 0.5
+        @gadget = File.open('/dev/hidg0', "w+")
+        @procon = File.open(PROCON2_PATH, "w+")
+        break
+      else
+        puts "プロコンをラズベイに挿してください"
+        sleep(1)
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/io_monitor.rb

@@ -0,0 +1,89 @@
+module ProconBypassMan
+  class Counter
+    attr_accessor :label, :table, :previous_table
+
+    def initialize(label: )
+      self.label = label
+      self.table = {}
+      self.previous_table = {}
+    end
+
+    # アクティブなバケットは1つだけ
+    def record(event_name)
+      return unless $is_stable
+      key = Time.now.strftime("%S").to_i
+      if table[key].nil?
+        self.previous_table = table.values.first
+        self.table = {}
+        table[key] = {}
+      end
+      if table[key][event_name].nil?
+        table[key][event_name] = 1
+      else
+        table[key][event_name] += 1
+      end
+      self
+    end
+
+    def formated_previous_table
+      t = previous_table.dup
+      start_function = t[:start_function] || 0
+      end_function = t[:end_function] || 0
+      eagain_wait_readable_on_read = t[:eagain_wait_readable_on_read] || 0
+      eagain_wait_readable_on_write = t[:eagain_wait_readable_on_write] || 0
+      "(#{(end_function / start_function.to_f * 100).floor(1)}%(#{end_function}/#{start_function}), loss: #{eagain_wait_readable_on_read}, #{eagain_wait_readable_on_write})"
+    end
+  end
+
+  module IOMonitor
+    def self.new(label: )
+      counter = Counter.new(label: label)
+      @@list << counter
+      counter
+    end
+
+    # @return [Array<Counter>]
+    def self.targets
+      @@list
+    end
+
+    # ここで集計する
+    def self.start!
+      Thread.start do
+        max_output_length = 0
+        loop do
+          list = @@list.dup
+          unless list.all? { |x| x&.previous_table.is_a?(Hash) }
+            sleep 0.5
+            next
+          end
+
+          s_to_p = list.detect { |x| x.label == "switch -> procon" }
+          previous_table = s_to_p&.previous_table.dup
+          if previous_table && previous_table.dig(:eagain_wait_readable_on_read) && previous_table.dig(:eagain_wait_readable_on_read) > 300
+            # ProconBypassMan.logger.debug { "接続の確立ができません" }
+            # Process.kill("USR1", Process.ppid)
+          end
+
+          line = list.map { |counter|
+            "#{counter.label}(#{counter.formated_previous_table})"
+          }.join(", ")
+          max_output_length = line.length
+          sleep 0.7
+          print "\r"
+          print " " * max_output_length
+          print "\r"
+          print line
+          ProconBypassMan.logger.debug { line }
+          break if $will_terminate_token
+        end
+      end
+    end
+
+    def self.reset!
+      @@list = []
+    end
+
+    reset!
+  end
+end