procon_bypass_man 0.1.2 → 0.1.6

data/lib/procon_bypass_man/configuration.rb

@@ -4,7 +4,6 @@ require "procon_bypass_man/configuration/layer"
 
 module ProconBypassMan
   class Configuration
-    include Validator
 
     attr_accessor :layers,
       :setting_path,
@@ -19,13 +18,12 @@ module ProconBypassMan
       @@context[@@current_context_key] ||= new
     end
 
-    def self.switch_context(key)
-      @@context[key] ||= new
+    def self.switch_new_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
@@ -39,11 +37,16 @@ module ProconBypassMan
 
     MODES = [:manual]
     def layer(direction, mode: :manual, &block)
-      unless (MODES + ProconBypassMan::Procon::ModeRegistry.plugins.keys).include?(mode)
-        raise("#{mode} mode is unknown")
+      if mode.respond_to?(:name)
+        mode_name = mode.name.to_sym
+      else
+        mode_name = mode
+      end
+      unless (MODES + ProconBypassMan::Procon::ModeRegistry.plugins.keys).include?(mode_name)
+        raise("#{mode_name} mode is unknown")
       end
 
-      layer = Layer.new(mode: mode)
+      layer = Layer.new(mode: mode_name)
       layer.instance_eval(&block) if block_given?
       self.layers[direction] = layer
       self

data/lib/procon_bypass_man/configuration/layer.rb

@@ -12,11 +12,11 @@ module ProconBypassMan
       end
 
       # @param [Symbol] button
-      def flip(button, if_pressed: false, channel: nil, force_neutral: nil)
+      def flip(button, if_pressed: false, force_neutral: nil, flip_interval: nil)
         case if_pressed
         when TrueClass
           if_pressed = [button]
-        when Symbol
+        when Symbol, String
           if_pressed = [if_pressed]
         when Array, FalseClass
           # sono mama
@@ -24,23 +24,52 @@ module ProconBypassMan
           raise "not support class"
         end
         hash = { if_pressed: if_pressed }
-        if channel
-          hash[:channel] = channel
-        end
         if force_neutral
-          hash[:force_neutral] = force_neutral
+          case force_neutral
+          when TrueClass, FalseClass
+            raise "ボタンを渡してください"
+          when Symbol, String
+            hash[:force_neutral] = [force_neutral]
+          when Array
+            hash[:force_neutral] = force_neutral
+          end
+        end
+
+        if flip_interval
+          if /\A(\d+)F\z/i =~ flip_interval
+            interval =  ((frame = $1.to_i) / 60.0).floor(2)
+          else
+            raise "8F みたいなフォーマットで入力してください"
+          end
+          hash[:flip_interval] = interval
+        end
+        if self.flips[button]
+          raise "#{button}への設定をすでに割り当て済みです"
+        else
+          self.flips[button] = hash
         end
-        self.flips[button] = hash
       end
 
       PRESET_MACROS = [:fast_return]
       def macro(name, if_pressed: )
-        self.macros[name] = { if_pressed: if_pressed }
+        if name.respond_to?(:name)
+          macro_name = name.name.to_sym
+        else
+          macro_name = name
+        end
+        self.macros[macro_name] = { if_pressed: if_pressed }
       end
 
       def remap(button, to: )
-        raise "シンボル以外は設定できません" unless to.is_a?(Symbol)
-        self.remaps[button] = to
+        case to
+        when TrueClass, FalseClass
+          raise "ボタンを渡してください"
+        when Symbol, String
+          self.remaps[button] = { to: [to] }
+        when Array
+          raise "ボタンを渡してください" if to.size.zero?
+          self.remaps[button] = { to: to }
+        end
       end
 
       # @return [Array]

data/lib/procon_bypass_man/configuration/loader.rb

@@ -1,24 +1,22 @@
 module ProconBypassMan
   class Configuration
     module Loader
+      require 'digest/md5'
+
       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)
+        ProconBypassMan::Configuration.switch_new_context(:validation) do |validation_instance|
+          yaml = YAML.load_file(setting_path) or raise "読み込みに失敗しました"
+          validation_instance.instance_eval(yaml["setting"])
+          validator = Validator.new(validation_instance)
+          if validator.valid?
+            next
+          else
+            raise ProconBypassMan::CouldNotLoadConfigError, validator.errors
           end
-          instance.valid?
-          next(instance)
-        end
-
-        if !validation_instance.errors.empty?
-          raise ProconBypassMan::CouldNotLoadConfigError, validation_instance.errors
+        rescue SyntaxError
+          raise ProconBypassMan::CouldNotLoadConfigError, "Rubyのシンタックスエラーです"
+        rescue Psych::SyntaxError
+          raise ProconBypassMan::CouldNotLoadConfigError, "yamlのシンタックスエラーです"
         end
 
         yaml = YAML.load_file(setting_path)
@@ -33,6 +31,9 @@ module ProconBypassMan
           ProconBypassMan.logger.warn "不明なバージョンです。failoverします"
           ProconBypassMan::Configuration.instance.instance_eval(yaml["setting"])
         end
+
+        File.write(ProconBypassMan.digest_path, Digest::MD5.hexdigest(yaml["setting"]))
+
         ProconBypassMan::Configuration.instance
       end
 

data/lib/procon_bypass_man/configuration/validator.rb

@@ -1,13 +1,19 @@
 module ProconBypassMan
   class Configuration
-    module Validator
+    class Validator
+      def initialize(config)
+        @layers = config.layers
+        @prefix_keys = config.prefix_keys
+      end
+
       # @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
+
+        validate_require_prefix_keys
+        validate_config_of_button_lonely
+        validate_verify_button_existence
+        validate_flip_and_remap_are_hate_each_other
 
         @errors.empty?
       end
@@ -21,6 +27,65 @@ module ProconBypassMan
       def errors
         @errors ||= Hash.new {|h,k| h[k] = [] }
       end
+
+      private
+
+      def validate_config_of_button_lonely
+        @layers.each do |layer_key, value|
+          if ProconBypassMan::Procon::ModeRegistry::PRESETS.key?(value.mode)
+            next
+          else
+            if !value.flips.empty? || !value.macros.empty?
+              @errors[:layers] << "#{layer_key}でmodeを設定しているのでボタンの設定はできません。"
+            end
+          end
+        end
+      end
+
+      def validate_require_prefix_keys
+        if @prefix_keys.empty?
+          @errors[:prefix_keys] ||= []
+          @errors[:prefix_keys] << "prefix_keys_for_changing_layerに値が入っていません。"
+        end
+      end
+
+      def validate_verify_button_existence
+        @layers.each do |layer_key, value|
+          unverified_buttons = []
+          # teplevel target button
+          value.flips.keys.map(&:to_sym).each { |b| unverified_buttons << b }
+          value.remaps.keys.map(&:to_sym).each { |b| unverified_buttons << b }
+          # internal target button
+          value.flips.flat_map { |_flip_button, flip_option|
+            flip_option.flat_map { |flip_option_key, flip_option_target_button|
+              next if flip_option_key == :flip_interval
+              next if flip_option_target_button.is_a?(FalseClass) || flip_option_target_button.is_a?(TrueClass)
+              flip_option_target_button
+            }
+          }.compact.each { |b| unverified_buttons << b }
+          value.remaps.flat_map { |_button, option|
+            option.flat_map { |_flip_option_key, flip_option_target_button|
+              next if flip_option_target_button.is_a?(FalseClass) || flip_option_target_button.is_a?(TrueClass)
+              flip_option_target_button
+            }
+          }.compact.each { |b| unverified_buttons << b }
+          unless(nunsupport_buttons = (unverified_buttons - ProconBypassMan::Procon::ButtonCollection::BUTTONS)).length.zero?
+            @errors[:layers] << "#{layer_key}で存在しないボタン#{nunsupport_buttons.join(", ")}があります"
+          end
+        end
+      end
+
+      def validate_flip_and_remap_are_hate_each_other
+        @layers.each do |layer_key, value|
+          flip_buttons = []
+          remap_buttons = []
+          value.flips.keys.map(&:to_sym).each { |b| flip_buttons << b }
+          value.remaps.keys.map(&:to_sym).each { |b| remap_buttons << b }
+          if(duplicated_buttons = flip_buttons & remap_buttons).length > 0
+            @errors[:layers] << "レイヤー#{layer_key}で、連打とリマップの定義が重複しているボタン#{duplicated_buttons.join(", ")}があります"
+          end
+        end
+      end
     end
   end
 end

data/lib/procon_bypass_man/device_connector.rb

@@ -0,0 +1,336 @@
+class ProconBypassMan::DeviceConnector
+  class BytesMismatchError < StandardError; end
+
+  class Value
+    attr_accessor :read_from, :values
+    def initialize(values: , read_from: )
+      @values = values
+      @read_from = read_from
+    end
+  end
+
+  PROCON_PATH = "/dev/hidraw0"
+  PROCON2_PATH = "/dev/hidraw1"
+
+  # 画面で再接続ができたが状況は変わらない
+  def self.reset_connection!
+    s = new
+    s.add([
+      ["0000"],
+      ["0000"],
+      ["8005"],
+      ["0000"],
+      ["8001"],
+    ], read_from: :switch)
+    s.drain_all
+    s.read_procon
+    s.write_switch("213c910080005db7723d48720a800300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
+    sleep(10) # いらないかも
+    s
+  end
+
+  def self.connect
+    s = new(throw_error_if_timeout: true, enable_at_exit: false)
+    s.add([
+      ["0000"],
+      ["0000"],
+      ["8005"],
+      ["0010"],
+    ], read_from: :switch)
+    # 1
+    s.add([["8001"]], read_from: :switch)
+    s.add([/^8101/], read_from: :procon) # <<< 81010003176d96e7a5480000000, macaddressとコントローラー番号を返す
+    # 2
+    s.add([["8002"]], read_from: :switch)
+    s.add([/^8102/], read_from: :procon)
+    # 3
+    s.add([/^0100/], read_from: :switch)
+    s.add([/^21/], read_from: :procon)
+    # 4
+    s.add([["8004"]], read_from: :switch)
+    s.drain_all
+    return [s.switch, s.procon]
+  end
+
+  def initialize(throw_error_if_timeout: false, throw_error_if_mismatch: false , enable_at_exit: true)
+    @stack = []
+    @initialized_devices = false
+    @throw_error_if_timeout = throw_error_if_timeout
+    @throw_error_if_mismatch = throw_error_if_mismatch
+    @enable_at_exit = enable_at_exit
+  end
+
+  def add(values, read_from: )
+    @stack << Value.new(values: values, read_from: read_from)
+  end
+
+  def drain_all
+    unless @initialized_devices
+      init_devices
+    end
+
+    while(item = @stack.shift)
+      item.values.each do |value|
+        data = nil
+        timer = ProconBypassMan::Timer.new
+        begin
+          timer.throw_if_timeout!
+          data = from_device(item).read_nonblock(128)
+        rescue IO::EAGAINWaitReadable
+          retry
+        end
+
+        result =
+          case value
+          when String, Array
+            value == data.unpack("H*")
+          when Regexp
+            value =~ data.unpack("H*").first
+          else
+            raise "#{value}は知りません"
+          end
+        if result
+          ProconBypassMan.logger.info "OK(expected: #{value}, got: #{data.unpack("H*")})"
+        else
+          ProconBypassMan.logger.info "NG(expected: #{value}, got: #{data.unpack("H*")})"
+          raise BytesMismatchError if @throw_error_if_mismatch
+        end
+        to_device(item).write_nonblock(data)
+      end
+    end
+  rescue ProconBypassMan::Timer::Timeout
+    ProconBypassMan.logger.error "timeoutになりました"
+    raise if @throw_error_if_timeout
+  end
+
+  # switchに任意の命令を入力して、switchから読み取る
+  def write_switch(data, only_write: false)
+    if data.encoding.name == "UTF-8"
+      data = [data].pack("H*")
+    end
+    unless @initialized_devices
+      init_devices
+    end
+
+    timer = ProconBypassMan::Timer.new
+    data = nil
+    begin
+      timer.throw_if_timeout!
+      switch.write_nonblock(data)
+    rescue IO::EAGAINWaitReadable
+      retry
+    rescue ProconBypassMan::Timer::Timeout
+      ProconBypassMan.logger.error "writeでtimeoutになりました"
+      raise
+    end
+    return(data.unpack("H*")) if only_write
+
+    timer = ProconBypassMan::Timer.new
+    begin
+      timer.throw_if_timeout!
+      data = switch.read_nonblock(128)
+      ProconBypassMan.logger.debug { " >>> #{data.unpack("H*")})" }
+    rescue IO::EAGAINWaitReadable
+      retry
+    rescue ProconBypassMan::Timer::Timeout
+      ProconBypassMan.logger.error "readでtimeoutになりました"
+      raise
+    end
+  rescue ProconBypassMan::Timer::Timeout
+    raise if @throw_error_if_timeout
+  end
+
+  def write_procon(data, only_write: false)
+    if data.encoding.name == "UTF-8"
+      data = [data].pack("H*")
+    end
+    unless @initialized_devices
+      init_devices
+    end
+
+    timer = ProconBypassMan::Timer.new
+    begin
+      timer.throw_if_timeout!
+      procon.write_nonblock(data)
+    rescue IO::EAGAINWaitReadable
+      retry
+    rescue ProconBypassMan::Timer::Timeout
+      ProconBypassMan.logger.error "writeでtimeoutになりました"
+      raise
+    end
+    return(data.unpack("H*")) if only_write
+
+    timer = ProconBypassMan::Timer.new
+    begin
+      timer.throw_if_timeout!
+      data = procon.read_nonblock(128)
+      ProconBypassMan.logger.error " <<< #{data.unpack("H*")})"
+    rescue IO::EAGAINWaitReadable
+      retry
+    rescue ProconBypassMan::Timer::Timeout
+      ProconBypassMan.logger.error "readでtimeoutになりました"
+      raise
+    end
+  rescue ProconBypassMan::Timer::Timeout
+    raise if @throw_error_if_timeout
+  end
+
+  def read_procon(only_read: false)
+    unless @initialized_devices
+      init_devices
+    end
+
+    data = nil
+    timer = ProconBypassMan::Timer.new
+    begin
+      timer.throw_if_timeout!
+      data = procon.read_nonblock(128)
+      ProconBypassMan.logger.debug { " <<< #{data.unpack("H*")})" }
+    rescue IO::EAGAINWaitReadable
+      retry
+    rescue ProconBypassMan::Timer::Timeout
+      ProconBypassMan.logger.error "readでtimeoutになりました"
+      raise
+    end
+    return(data.unpack("H*")) if only_read
+
+    timer = ProconBypassMan::Timer.new
+    begin
+      timer.throw_if_timeout!
+      switch.write_nonblock(data)
+    rescue IO::EAGAINWaitReadable
+      retry
+    rescue ProconBypassMan::Timer::Timeout
+      ProconBypassMan.logger.error "writeでtimeoutになりました"
+      raise
+    end
+  rescue ProconBypassMan::Timer::Timeout
+    raise if @throw_error_if_timeout
+  end
+
+  def read_switch(only_read: false)
+    unless @initialized_devices
+      init_devices
+    end
+
+    data = nil
+    timer = ProconBypassMan::Timer.new
+    begin
+      timer.throw_if_timeout!
+      data = switch.read_nonblock(128)
+      ProconBypassMan.logger.debug { " >>> #{data.unpack("H*")})" }
+    rescue IO::EAGAINWaitReadable
+      retry
+    rescue ProconBypassMan::Timer::Timeout
+      ProconBypassMan.logger.error "readでtimeoutになりました"
+      raise
+    end
+    return(data.unpack("H*")) if only_read
+
+    timer = ProconBypassMan::Timer.new
+    begin
+      timer.throw_if_timeout!
+      procon.write_nonblock(data)
+    rescue IO::EAGAINWaitReadable
+      retry
+    rescue ProconBypassMan::Timer::Timeout
+      ProconBypassMan.logger.error "writeでtimeoutになりました"
+      raise
+    end
+  rescue ProconBypassMan::Timer::Timeout
+    raise if @throw_error_if_timeout
+  end
+
+  def from_device(item)
+    case item.read_from
+    when :switch
+      switch
+    when :procon
+      procon
+    else
+      raise
+    end
+  end
+
+  # fromの対になる
+  def to_device(item)
+    case item.read_from
+    when :switch
+      procon
+    when :procon
+      switch
+    else
+      raise
+    end
+  end
+
+  def switch
+    @gadget
+  end
+
+  def procon
+    @procon
+  end
+
+  def is_available_device?(path)
+    return false if !File.exist?(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
+
+    file = File.open(path, "w+")
+    begin
+      file.read_nonblock(128)
+    rescue EOFError
+      file.close
+      return false
+    rescue IO::EAGAINWaitReadable
+      file.close
+      return true
+    end
+  end
+
+  def to_bin(string)
+    string.unpack "H*"
+  end
+
+  def init_devices
+    if @initialized_devices
+      return
+    end
+
+    case
+    when is_available_device?(PROCON_PATH)
+      ProconBypassMan.logger.info "proconのデバイスファイルは#{PROCON_PATH}を使います"
+      @procon = File.open(PROCON_PATH, "w+")
+      @gadget = File.open('/dev/hidg0', "w+")
+    when is_available_device?(PROCON2_PATH)
+      ProconBypassMan.logger.info "proconのデバイスファイルは#{PROCON2_PATH}を使います"
+      @procon = File.open(PROCON2_PATH, "w+")
+      @gadget = File.open('/dev/hidg0', "w+")
+    else
+      raise "/dev/hidraw0, /dev/hidraw1の両方見つかりませんでした"
+    end
+    system('echo > /sys/kernel/config/usb_gadget/procon/UDC')
+    system('ls /sys/class/udc > /sys/kernel/config/usb_gadget/procon/UDC')
+    sleep 0.5
+
+    @initialized_devices = true
+
+    if @enable_at_exit
+      at_exit do
+        @procon&.close
+        @gadget&.close
+      end
+    end
+  rescue Errno::ENXIO => e
+    # /dev/hidg0 をopenできないときがある
+    ProconBypassMan.logger.error "Errno::ENXIO (No such device or address @ rb_sysopen - /dev/hidg0)が起きました。resetします"
+    ProconBypassMan.logger.error e
+    system('echo > /sys/kernel/config/usb_gadget/procon/UDC')
+    system('ls /sys/class/udc > /sys/kernel/config/usb_gadget/procon/UDC')
+    sleep 2
+    retry
+  end
+end