procon_bypass_man 0.1.23 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0250a1a8546982fa0d1924606cfeb65b0376b1f0bbd2849a8c6faba39551c1a
-  data.tar.gz: 94301f2c9540d370e55479f9ae818de0b0e64ece99b7ad7b44698f8828e241d4
+  metadata.gz: 6ca0c509c42d13cd0a9177c80b09c7f31bbeb6fad810e0f85210811cd69bffa2
+  data.tar.gz: ae97eb1796fb709840dcac7138e8ac8a2fd8be15f134585da8538f3958fb3442
 SHA512:
-  metadata.gz: 8819eed593368519dde453cdb44168c4d05066ec6a52d22b8ca61f57a4f67d59307b41d4cb814a9b89dc2590cab17036ab2c2acf6c460213193cecf3380f8cb7
-  data.tar.gz: 5ba74b2733493a2efb74fd9f73ffa5d6a9103acb5e1bd2d050e5c14146e739da4b48e25e84431cab1655e3d9a48a5f8249974f66da5ecc55f8efb4a66c3e86e7
+  metadata.gz: 33f58604e017bc01b6f7057877ab79045456f7fb10ff880fe640b47195374c8f170f5d5e7f97f643148d5b06313a3b9c6cfbd77d0e2701875e3bd1e6d4e397b1
+  data.tar.gz: d69d376c75ef7692ae7d2c74e8715aa00bea4dfbe2ff6d7359b69bbdff5ef65cd39132f82dcaa297c60fd3459ac9aff66f0751d2cc2e818e613bbd53cef2f829

data/.github/workflows/gitleacks.yml

@@ -0,0 +1,11 @@
+name: gitleaks
+
+on: [push]
+
+jobs:
+  gitleaks:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: gitleaks-action
+      uses: zricethezav/gitleaks-action@master

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.2.0] - 2022-05-20
+- 3つ以上のボタンを操作するマクロに対応する
+- IOに関するログをデフォルトで無効にしました
+  - 有効にする場合はapp.rbに `config.io_monitor_logging = true` を記述してください
+- 接続が安定化するまでの時間が短くなりました
+- 接続中にプロコンのケーブルを抜くと、エラーを吐いて終了できなくなる不具合を修正しました
+- プロセスをCtrl+Cで停止するときに終了するまでの時間が短くなりました
+- 接続に成功するとhomeボタンのledが光るようになりました
+  - 無効にする場合はapp.rbに `config.enable_home_led_on_connect = false` を記述してください
+
 ## [0.1.23] - 2022-05-04
 - プロセスを停止するとプロコンがBluetooth経由でSwitchと接続するようになりました
 - 起動時に表示するdevice_idを一部のみ表示するようになりました

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    procon_bypass_man (0.1.23)
+    procon_bypass_man (0.2.0)
       action_cable_client
       pbmenv (>= 0.1.9)
       sorted_set

data/docs/setup_raspi.md

@@ -33,7 +33,6 @@ https://github.com/splaplapla/procon_bypass_man/blob/master/docs/setup_raspi_by_
   * chmod 755 ~/add_procon_gadget.sh
   * sudo reboot
   * sudo sh ~/add_procon_gadget.sh の実行に成功させる
-  *  /etc/rc.local に sh /home/pi/add_procon_gadget.sh って書く
 * cd ~ && mkdir -p src && cd ~/src && git clone https://github.com/jiikko/procon_bypass_man_sample && cd procon_bypass_man_sample
 
 おわり. 起動する時は都度 sudo ruby app.rb を実行する

data/lib/procon_bypass_man/buttons_setting_configuration/loader.rb

@@ -32,7 +32,7 @@ module ProconBypassMan
         ProconBypassMan::ButtonsSettingConfiguration.instance.reset!
         ProconBypassMan.reset!
 
-        yaml = YAML.load_file(setting_path)
+        yaml = ProconBypassMan::YamlLoader.load(path: setting_path)
         ProconBypassMan.config.raw_setting = yaml.dup
         case yaml["version"]
         when 1.0, nil

data/lib/procon_bypass_man/{commands → bypass}/bypass_command.rb

@@ -10,7 +10,7 @@ class ProconBypassMan::BypassCommand
     @gadget = gadget
     @procon = procon
 
-    ProconBypassMan::IOMonitor.start!
+    ProconBypassMan::IOMonitor.start! if ProconBypassMan.io_monitor_logging
     ProconBypassMan::Background::JobRunner.queue.clear # forkしたときに残留物も移ってしまうため
     ProconBypassMan::Background::JobRunner.start!
   end
@@ -33,32 +33,22 @@ class ProconBypassMan::BypassCommand
     monitor2 = ProconBypassMan::IOMonitor.new(label: "procon -> switch")
     ProconBypassMan.logger.info "Thread1を起動します"
 
-    cycle_sleep = ProconBypassMan::CycleSleep.new(cycle_interval: 0.005, execution_cycle: 0)
+    cycle_sleep = ProconBypassMan::CycleSleep.new(cycle_interval: 1, execution_cycle: ProconBypassMan.config.bypass_mode.gadget_to_procon_interval)
 
     t1 = Thread.new do
-      timer = ProconBypassMan::SafeTimeout.new(timeout: Time.now + 10)
-      @did_first_step = false
+      if ProconBypassMan.config.bypass_mode.mode == ProconBypassMan::BypassMode::TYPE_AGGRESSIVE
+        ProconBypassMan.logger.info "TYPE_AGGRESSIVEなのでThread1を終了します"
+        monitor1.shutdown
+        next
+      end
+
       loop do
         break if $will_terminate_token
 
         cycle_sleep.sleep_or_execute do
           bypass = ProconBypassMan::Bypass.new(gadget: @gadget, procon: @procon, monitor: monitor1)
-          !@did_first_step && timer.throw_if_timeout!
           bypass.send_gadget_to_procon!
         end
-      rescue ProconBypassMan::SafeTimeout::Timeout
-        case ProconBypassMan.config.bypass_mode.mode
-        when ProconBypassMan::BypassMode::TYPE_AGGRESSIVE
-          ProconBypassMan.logger.info "10秒経過したのでThread1を終了します"
-          monitor1.shutdown
-          break
-        when ProconBypassMan::BypassMode::TYPE_NORMAL
-          ProconBypassMan.logger.info "10秒経過したのでsend_intervalを長くします"
-          cycle_sleep = ProconBypassMan::CycleSleep.new(cycle_interval: 1, execution_cycle: ProconBypassMan.config.bypass_mode.gadget_to_procon_interval)
-        else
-          raise "unknown type"
-        end
-        @did_first_step = true
       rescue Errno::EIO, Errno::ENODEV, Errno::EPROTO, IOError, Errno::ESHUTDOWN => e
         ProconBypassMan::SendErrorCommand.execute(error: "Switchとの切断されました.終了処理を開始します. #{e.full_message}")
         Process.kill "TERM", Process.ppid
@@ -67,6 +57,7 @@ class ProconBypassMan::BypassCommand
         ProconBypassMan::SendErrorCommand.execute(error: "Switchと意図せず切断されました.終了処理を開始します. #{e.full_message}")
         Process.kill "TERM", Process.ppid
       end
+
       ProconBypassMan.logger.info "Thread1を終了します"
     end
 
@@ -79,7 +70,6 @@ class ProconBypassMan::BypassCommand
         if $will_terminate_token
           if $will_terminate_token == WILL_TERMINATE_TOKEN::TERMINATE
             bypass.direct_connect_switch_via_bluetooth
-            bypass.be_empty_procon
           end
           break
         end
@@ -88,9 +78,11 @@ class ProconBypassMan::BypassCommand
       rescue EOFError => e
         ProconBypassMan::SendErrorCommand.execute(error: "Proconが切断されました。終了処理を開始します. #{e.full_message}")
         Process.kill "TERM", Process.ppid
+        break
       rescue Errno::EIO, Errno::ENODEV, Errno::EPROTO, IOError, Errno::ESHUTDOWN => e
         ProconBypassMan::SendErrorCommand.execute(error: "Proconが切断されました。終了処理を開始します2. #{e.full_message}")
         Process.kill "TERM", Process.ppid
+        break
       end
       ProconBypassMan.logger.info "Thread2を終了します"
     end

data/lib/procon_bypass_man/bypass.rb

@@ -1,4 +1,5 @@
 require "procon_bypass_man/bypass/usb_hid_logger"
+require "procon_bypass_man/bypass/bypass_command"
 
 class ProconBypassMan::Bypass
   include ProconBypassMan::Bypass::UsbHidLogger
@@ -28,7 +29,6 @@ class ProconBypassMan::Bypass
 
       raw_input = nil
       begin
-        # TODO blocking readにしたいが、接続時のフェーズによって長さが違うので厳しい
         raw_input = self.gadget.read_nonblock(64)
         self.bypass_value.binary = ProconBypassMan::Domains::InboundProconBinary.new(binary: raw_input)
       rescue IO::EAGAINWaitReadable
@@ -97,6 +97,10 @@ class ProconBypassMan::Bypass
   # @return [void]
   def direct_connect_switch_via_bluetooth
     ProconBypassMan.logger.debug { "direct_connect_switch_via_bluetooth!" }
+    self.procon.write_nonblock(["010500000000000000003800"].pack("H*")) # home led off
+    self.procon.write_nonblock(["010600000000000000003800"].pack("H*")) # home led off
+    self.procon.write_nonblock(["010700000000000000003800"].pack("H*")) # home led off
+    self.procon.write_nonblock(["010800000000000000003800"].pack("H*")) # home led off
     self.procon.write_nonblock(["8005"].pack("H*"))
     self.procon.write_nonblock(["8005"].pack("H*"))
     self.procon.write_nonblock(["8005"].pack("H*"))
@@ -104,13 +108,6 @@ class ProconBypassMan::Bypass
 
   # @return [void] 入力してから取り出さないと接続しっぱなしになるっぽいのでこれが必要っぽい
   def be_empty_procon
-    timer = ProconBypassMan::SafeTimeout.new(timeout: Time.now + 5)
-    loop do
-      break if timer.timeout?
-      output = self.procon.read_nonblock(64)
-      ProconBypassMan.logger.debug { "[ProconBypassMan::Bypass#be_empty_procon] #{output.unpack("H*").first}" }
-    rescue IO::EAGAINWaitReadable
-      # no-op
-    end
+    # タイムアウトまでブロッキングされるので、プロセスに逃す
   end
 end

data/lib/procon_bypass_man/commands/print_boot_message_command.rb

@@ -32,8 +32,8 @@ class ProconBypassMan::PrintBootMessageCommand
     def to_s
       booted_message = <<~EOF
       ----
-      RUBY_VERSION: #{@table[:ruby_version]}
       ProconBypassMan::VERSION: #{@table[:pbm_version]}
+      RUBY_VERSION: #{@table[:ruby_version]}
       Pbmenv::VERSION: #{@table[:pbmenv_version]}
       pid: #{@table[:pid]}
       root: #{@table[:root_path]}
@@ -58,7 +58,6 @@ class ProconBypassMan::PrintBootMessageCommand
   def self.execute
     message = BootMessage.new
     ProconBypassMan::ReportBootJob.perform_async(message.to_hash)
-    ProconBypassMan::ReportLoadConfigJob.perform_async(ProconBypassMan.config.raw_setting)
     puts message.to_s
   end
 end

data/lib/procon_bypass_man/commands/send_error_command.rb

@@ -1,7 +1,7 @@
 class ProconBypassMan::SendErrorCommand
   # @param [String, Hash, Exception] error
   # @return [void]
-  def self.execute(error: )
+  def self.execute(error: , stdout: true)
     body =
       case error
       when String, Hash
@@ -12,7 +12,7 @@ class ProconBypassMan::SendErrorCommand
 
     ProconBypassMan.logger.error body
     ProconBypassMan.error_logger.error body
-    puts body
+    puts body if stdout
 
     ProconBypassMan::ReportErrorJob.perform(error)
   end

data/lib/procon_bypass_man/commands.rb

@@ -4,6 +4,3 @@ require "procon_bypass_man/commands/write_session_id_command"
 require "procon_bypass_man/commands/write_device_id_command"
 require "procon_bypass_man/commands/send_reload_config_event_command"
 require "procon_bypass_man/commands/send_error_command"
-require "procon_bypass_man/commands/connect_device_command"
-require "procon_bypass_man/commands/bypass_command"
-require "procon_bypass_man/commands/run_remote_pbm_action_dispatch_command"

data/lib/procon_bypass_man/configuration.rb

@@ -47,10 +47,14 @@ class ProconBypassMan::Configuration
     def fallback_setting_path
       "/tmp/procon_bypass_man_fallback_setting.yaml"
     end
+
+    def io_monitor_logging
+      config.io_monitor_logging
+    end
   end
 
   attr_accessor :enable_critical_error_logging
-  attr_writer :verbose_bypass_log, :raw_setting, :enable_reporting_pressed_buttons, :never_exit_accidentally
+  attr_writer :verbose_bypass_log, :raw_setting, :enable_reporting_pressed_buttons, :never_exit_accidentally, :io_monitor_logging, :enable_home_led_on_connect
 
   def root=(path)
     @root = path
@@ -186,12 +190,27 @@ class ProconBypassMan::Configuration
     @raw_setting ||= {}
   end
 
+  # @return [Boolean] default false
   def enable_reporting_pressed_buttons
     @enable_reporting_pressed_buttons ||= false
   end
 
-  # @return [Boolean]
+  # @return [Boolean] default false
   def never_exit_accidentally
     @never_exit_accidentally || false
   end
+
+  # @return [Boolean] default false
+  def io_monitor_logging
+    @io_monitor_logging ||= false
+  end
+
+  # @return [Boolean] default true
+  def enable_home_led_on_connect
+    if defined?(@enable_home_led_on_connect)
+      return @enable_home_led_on_connect
+    else
+      true
+    end
+  end
 end

data/lib/procon_bypass_man/device_connection/command.rb

@@ -0,0 +1,28 @@
+class ProconBypassMan::DeviceConnection::Command
+  MAX_RETRY_COUNT = 3
+
+  # @return [void]
+  def self.execute!(retry_count: 0)
+    begin
+      gadget, procon = ProconBypassMan::DeviceConnection::Executer.execute!
+    rescue ProconBypassMan::DeviceConnection::TimeoutErrorInConditionalRoute
+      if retry_count >= MAX_RETRY_COUNT
+        ProconBypassMan::SendErrorCommand.execute(error: "リトライしましたが、接続できませんでした")
+        raise ProconBypassMan::DeviceConnection::TimeoutError
+      else
+        ProconBypassMan::SendErrorCommand.execute(error: "接続に失敗したのでリトライします")
+      end
+
+      retry_count = retry_count + 1
+      retry
+    rescue ProconBypassMan::DeviceConnection::NotFoundProconError => e
+      raise
+    rescue ProconBypassMan::SafeTimeout::Timeout
+      raise ProconBypassMan::DeviceConnection::TimeoutError
+    end
+
+    ProconBypassMan::DeviceConnection::PreBypass.new(gadget: gadget, procon: procon).execute!
+    ProconBypassMan::DeviceConnection::ProconSettingOverrider.new(procon: procon).execute!
+    return [gadget, procon]
+  end
+end

data/lib/procon_bypass_man/{device_connector.rb → device_connection/executor.rb}

@@ -1,9 +1,6 @@
 require "timeout"
 
-class ProconBypassMan::DeviceConnector
-  class BytesMismatchError < StandardError; end
-  class NotFoundProconError < StandardError; end
-
+class ProconBypassMan::DeviceConnection::Executer
   class Value
     attr_accessor :read_from, :values, :call_block_if_receive, :block
 
@@ -15,33 +12,41 @@ class ProconBypassMan::DeviceConnector
     end
   end
 
-  def self.connect
-    s = new(throw_error_if_timeout: true)
-    s.add([
+  def self.new_with_default_args
+    new(throw_error_if_timeout: true)
+  end
+
+  def self.execute!
+    s = new_with_default_args
+    s.add(expected_to_receive: [
       ["0000"],
       ["0000"],
       ["8005"],
       ["0000"],
     ], read_from: :switch)
     # 1. Sends current connection status, and if the Joy-Con are connected,
-    s.add([["8001"]], read_from: :switch)
-    s.add([/^8101/], read_from: :procon) # <<< 81010003176d96e7a5480000000, macaddressとコントローラー番号を返す
+    s.add(expected_to_receive: [["8001"]], read_from: :switch)
+    s.add(expected_to_receive: [/^8101/], read_from: :procon) # <<< 81010003176d96e7a5480000000, macaddressとコントローラー番号を返す
     # 2. Sends handshaking packets over UART to the Joy-Con or Pro Controller Broadcom chip. This command can only be called once per session.
-    s.add([["8002"]], read_from: :switch)
-    s.add([/^8102/], read_from: :procon)
+    s.add(expected_to_receive: [["8002"]], read_from: :switch)
+    s.add(expected_to_receive: [/^8102/], read_from: :procon)
     # 3
-    s.add([/^0100/], read_from: :switch)
-    s.add([/^21/], read_from: :procon, call_block_if_receive: /^8101/) do |this|
-      ProconBypassMan.logger.info "(start special route)"
-      this.blocking_read_with_timeout_from_procon # <<< 810100032dbd42e9b698000
-      this.write_to_procon("8002")
-      this.blocking_read_with_timeout_from_procon # <<< 8102
-      this.write_to_procon("01000000000000000000033000000000000000000000000000000000000000000000000000000000000000000000000000")
-      this.blocking_read_with_timeout_from_procon # <<< 21
+    s.add(expected_to_receive: [/^0100/], read_from: :switch)
+    s.add(expected_to_receive: [/^21/], read_from: :procon, call_block_if_receive: /^8101/) do |this|
+      begin
+        ProconBypassMan.logger.info "(start special route)"
+        this.blocking_read_with_timeout_from_procon # <<< 810100032dbd42e9b698000
+        this.write_to_procon("8002")
+        this.blocking_read_with_timeout_from_procon # <<< 8102
+        this.write_to_procon("01000000000000000000033000000000000000000000000000000000000000000000000000000000000000000000000000")
+        this.blocking_read_with_timeout_from_procon # <<< 21
+      rescue ProconBypassMan::SafeTimeout::Timeout, Timeout::Error
+        raise ProconBypassMan::DeviceConnection::TimeoutErrorInConditionalRoute
+      end
     end
 
     # 4. Forces the Joy-Con or Pro Controller to only talk over USB HID without any timeouts. This is required for the Pro Controller to not time out and revert to Bluetooth.
-    s.add([["8004"]], read_from: :switch)
+    s.add(expected_to_receive: [["8004"]], read_from: :switch)
     s.drain_all
     return [s.switch, s.procon]
   end
@@ -53,7 +58,8 @@ class ProconBypassMan::DeviceConnector
     @throw_error_if_mismatch = throw_error_if_mismatch
   end
 
-  def add(values, read_from: , call_block_if_receive: false, &block)
+  def add(expected_to_receive: , read_from: , call_block_if_receive: nil, &block)
+    values = expected_to_receive
     @queue << Value.new(values: values, read_from: read_from, call_block_if_receive: call_block_if_receive, &block)
   end
 
@@ -67,6 +73,7 @@ class ProconBypassMan::DeviceConnector
       item.values.each do |value|
         raw_data = nil
         timer = ProconBypassMan::SafeTimeout.new
+
         begin
           timer.throw_if_timeout!
           raw_data = from_device(item).read_nonblock(64)
@@ -76,8 +83,11 @@ class ProconBypassMan::DeviceConnector
           retry
         end
 
-        if item.call_block_if_receive =~ raw_data.unpack("H*").first
-          raw_data = item.block.call(self)
+        if item.call_block_if_receive
+          ProconBypassMan.logger.info "call block if receive: #{item.call_block_if_receive}, actual: #{raw_data.unpack("H*")} from: #{item.read_from}"
+          if item.call_block_if_receive =~ raw_data.unpack("H*").first
+            raw_data = item.block.call(self)
+          end
         end
 
         result =
@@ -89,13 +99,14 @@ class ProconBypassMan::DeviceConnector
           else
             raise "#{value}は知りません"
           end
+
         if result
-          ProconBypassMan.logger.info "OK(expected: #{value}, got: #{raw_data.unpack("H*")})"
-          debug_log_buffer << "OK(expected: #{value}, got: #{raw_data.unpack("H*")})"
+          ProconBypassMan.logger.info "OK(expected: #{value}, got: #{raw_data.unpack("H*")}) from: #{item.read_from}"
+          debug_log_buffer << "OK(expected: #{value}, got: #{raw_data.unpack("H*")}) from: #{item.read_from}"
         else
-          ProconBypassMan.logger.info "NG(expected: #{value}, got: #{raw_data.unpack("H*")})"
-          debug_log_buffer << "NG(expected: #{value}, got: #{raw_data.unpack("H*")})"
-          raise BytesMismatchError.new(debug_log_buffer) if @throw_error_if_mismatch
+          ProconBypassMan.logger.info "NG(expected: #{value}, got: #{raw_data.unpack("H*")}) from: #{item.read_from}"
+          debug_log_buffer << "NG(expected: #{value}, got: #{raw_data.unpack("H*")}) from: #{item.read_from}"
+          raise ProconBypassMan::DeviceConnection::BytesMismatchError.new(debug_log_buffer) if @throw_error_if_mismatch
         end
         to_device(item).write_nonblock(raw_data)
       end
@@ -103,8 +114,8 @@ class ProconBypassMan::DeviceConnector
   rescue ProconBypassMan::SafeTimeout::Timeout, Timeout::Error => e
     ProconBypassMan.logger.error "timeoutになりました(#{e.message})"
     compressed_buffer_text = ProconBypassMan::CompressArray.new(debug_log_buffer).compress.join("\n")
-    ProconBypassMan::SendErrorCommand.execute(error: compressed_buffer_text)
-    raise if @throw_error_if_timeout
+    ProconBypassMan::SendErrorCommand.execute(error: compressed_buffer_text, stdout: false)
+    raise ProconBypassMan::SafeTimeout::Timeout if @throw_error_if_timeout
   end
 
   def from_device(item)
@@ -143,23 +154,25 @@ class ProconBypassMan::DeviceConnector
       return
     end
     ProconBypassMan::UsbDeviceController.init
+    ProconBypassMan::UsbDeviceController.reset
 
     if path = ProconBypassMan::DeviceProconFinder.find
       @procon = File.open(path, "w+b")
       ProconBypassMan.logger.info "proconのデバイスファイルは#{path}を使います"
     else
-      raise(ProconBypassMan::DeviceConnector::NotFoundProconError)
+      raise(ProconBypassMan::DeviceConnection::NotFoundProconError)
     end
-    @gadget = File.open('/dev/hidg0', "w+b")
 
-    ProconBypassMan::UsbDeviceController.reset
+    begin
+      @gadget = File.open('/dev/hidg0', "w+b")
+    rescue Errno::ENXIO => e
+      # /dev/hidg0 をopenできないときがある
+      ProconBypassMan::SendErrorCommand.execute(error: "Errno::ENXIOが起きたのでresetします.\n #{e.full_message}", stdout: false)
+      ProconBypassMan::UsbDeviceController.reset
+      retry
+    end
 
     @initialized_devices = true
-  rescue Errno::ENXIO => e
-    # /dev/hidg0 をopenできないときがある
-    ProconBypassMan::SendErrorCommand.execute(error: "Errno::ENXIO (No such device or address @ rb_sysopen - /dev/hidg0)が起きました。resetします.\n #{e.full_message}")
-    ProconBypassMan::UsbDeviceController.reset
-    retry
   end
 
   def blocking_read_with_timeout_from_procon

data/lib/procon_bypass_man/device_connection/output_report_generator.rb

@@ -0,0 +1,42 @@
+class ProconBypassMan::DeviceConnection::OutputReportGenerator
+  def initialize
+    @counter = 0
+  end
+
+  # @return [String]
+  def generate_by_step(step)
+    sub_command_with_arg = ProconBypassMan::DeviceConnection::ProconSettingOverrider::ALL_SETTINGS[step]&.join or raise("Unsupport step")
+    raw_data = generate(sub_command_with_arg)
+    count_up
+    raw_data
+  end
+
+  # @return [String]
+  def generate_by_sub_command_with_arg(sub_command_with_arg)
+    raw_data = generate(sub_command_with_arg)
+    count_up
+    raw_data
+  end
+
+  private
+
+  # @return [String]
+  def generate(sub_command_with_arg)
+    [
+      ["01", counter, "00" * 8, sub_command_with_arg].join
+    ].pack("H*")
+  end
+
+  def count_up
+    @counter = @counter + 1
+    if @counter >= 256
+      @counter = 0
+    else
+      @counter
+    end
+  end
+
+  def counter
+    @counter.to_s(16).rjust(2, "0")
+  end
+end

data/lib/procon_bypass_man/device_connection/output_report_markerable.rb

@@ -0,0 +1,28 @@
+module ProconBypassMan::DeviceConnection::OutputReportMarkerable
+  OUTPUT_REPORT_FORMAT = /^01/
+  INPUT_REPORT_FORMAT = /^21/
+
+  # @param [String] raw_data
+  # @return [void]
+  def mark_as_send(raw_data)
+    data = raw_data.unpack("H*").first
+    case data
+    when OUTPUT_REPORT_FORMAT
+      sub_command = data[20..21]
+      sub_command_arg = data[22..23]
+      @hid_sub_command_request_table.mask_as_send(sub_command: sub_command, sub_command_arg: sub_command_arg)
+    end
+  end
+
+  # @param [String] raw_data
+  # @return [void]
+  def mark_as_receive(raw_data)
+    data = raw_data.unpack("H*").first
+    case data
+    when INPUT_REPORT_FORMAT
+      sub_command = data[28..29]
+      sub_command_arg = data[30..31]
+      @hid_sub_command_request_table.mark_as_receive(sub_command: sub_command, sub_command_arg: sub_command_arg)
+    end
+  end
+end

data/lib/procon_bypass_man/device_connection/output_report_sub_command_table.rb

@@ -0,0 +1,133 @@
+class ProconBypassMan::DeviceConnection::OutputReportSubCommandTable
+  class HIDSubCommandResponse
+    attr_accessor :sub_command, :sub_command_arg
+
+    def initialize(sub_command: , sub_command_arg: )
+      @sub_command = sub_command
+      @sub_command_arg = sub_command_arg
+    end
+
+    def sub_command_with_arg
+      case @sub_command
+      when *SPECIAL_SUB_COMMANDS
+        @sub_command
+      else
+        if @sub_command_arg
+          "#{@sub_command}-#{@sub_command_arg}"
+        else
+          @sub_command
+        end
+      end
+    end
+  end
+
+  IGNORE_SUB_COMMANDS = {
+    "48-01" => true,
+    "04-00" => true,
+  }
+  # レスポンスに引数が含まれない
+  SPECIAL_SUB_COMMANDS = [
+    "01",
+    "02",
+    "03",
+    "30",
+    "38", # home led
+    "40",
+    "48",
+  ]
+
+  EXPECTED_SUB_COMMANDS = [
+    "01-04",
+    "02-",
+    "04-00",
+    "08-00",
+    "10-00",
+    "10-50",
+    "10-80",
+    "10-98",
+    "10-10",
+    "10-28",
+    "30-",
+    "40-",
+    "48-", # Enable vibration
+  ]
+
+  def initialize
+    @table = {}
+  end
+
+  # @param [String] sub_command
+  # @param [String] sub_command_arg
+  # @return [void]
+  def mask_as_send(sub_command: , sub_command_arg: )
+    case sub_command
+    when *SPECIAL_SUB_COMMANDS
+      @table[sub_command] = false
+    else
+      response = HIDSubCommandResponse.new(sub_command: sub_command, sub_command_arg: sub_command_arg)
+      @table[response.sub_command_with_arg] = false
+    end
+  end
+
+  # @param [String] sub_command
+  # @param [String] sub_command_arg
+  # @return [void]
+  def mark_as_receive(sub_command: , sub_command_arg: )
+    response = HIDSubCommandResponse.new(sub_command: sub_command, sub_command_arg: sub_command_arg)
+    if @table.key?(response.sub_command_with_arg)
+      @table[response.sub_command_with_arg] = true
+    end
+  end
+
+  # @param [String] sub_command
+  # @param [String] sub_command_arg
+  # @return [Boolean]
+  def has_key?(sub_command: , sub_command_arg: )
+    if IGNORE_SUB_COMMANDS["#{sub_command}-#{sub_command_arg}"]
+      return true
+    end
+
+    case sub_command
+    when *SPECIAL_SUB_COMMANDS
+      @table.key?(sub_command)
+    else
+      response = HIDSubCommandResponse.new(sub_command: sub_command, sub_command_arg: sub_command_arg)
+      @table.key?(response.sub_command_with_arg)
+    end
+  end
+
+  # @param [String] sub_command
+  # @param [String] sub_command_arg
+  # @return [Boolean]
+  def has_value?(sub_command: , sub_command_arg: )
+    if IGNORE_SUB_COMMANDS["#{sub_command}-#{sub_command_arg}"]
+      return true
+    end
+
+    response = HIDSubCommandResponse.new(sub_command: sub_command, sub_command_arg: sub_command_arg)
+    !!@table[response.sub_command_with_arg]
+  end
+
+  # @return [Boolean]
+  def has_unreceived_command?
+    !@table.values.all?(&:itself)
+  end
+
+  # @return [String, NilClass]
+  def unreceived_sub_command_with_arg
+    sub_command = @table.detect { |_key, value| !value }&.first
+    if(arg = ProconBypassMan::DeviceConnection::ProconSettingOverrider::SPECIAL_SUB_COMMAND_ARGS[sub_command])
+      "#{sub_command}#{arg}"
+    else
+      sub_command
+    end
+  end
+
+  # @return [Boolean]
+  def completed?
+    EXPECTED_SUB_COMMANDS.all? do |key|
+      sub_command, sub_command_arg = key.split("-")
+      has_value?(sub_command: sub_command, sub_command_arg: sub_command_arg)
+    end
+  end
+end