pwn 0.5.514 → 0.5.516

data/lib/pwn/sdr/gqrx.rb

@@ -16,10 +16,10 @@ module PWN
 
       Integer.class_eval do
         # Should always return format of X.XXX.XXX.XXX
-        # So 002_450_000_000 becomes 2.450.000.000
-        # So 2_450_000_000 becomes 2.450.000.000
-        # So 960_000_000 becomes 960.000.000
-        # 1000 should be 1.000
+        # So 002_450_000_000 becomes 2.450.000.000 = 2.45 GHz
+        # So 2_450_000_000 becomes 2.450.000.000 = 2.45 GHz
+        # So 960_000_000 becomes 960.000.000 = 960 MHz
+        # 1000 should be 1.000 = 1 kHz
         def cast_to_pretty_hz
           str_hz = to_s
           # Nuke leading zeros
@@ -141,11 +141,7 @@ module PWN
           response.push(gqrx_sock.readline.chomp)
           # Drain any additional lines quickly
           loop do
-            # This is the main contributing factor to this scanner being slow.
-            # We're trading speed for accuracy here.
-            # break if gqrx_sock.wait_readable(0.0625).nil? && cmd == 'l STRENGTH'
-            break if gqrx_sock.wait_readable(0.04).nil? && cmd == 'l STRENGTH'
-            break if gqrx_sock.wait_readable(0.001).nil? && cmd != 'l STRENGTH'
+            break if gqrx_sock.wait_readable(0.0001).nil?
 
             response.push(gqrx_sock.readline.chomp)
           end
@@ -162,37 +158,92 @@ module PWN
 
         response_str
       rescue RuntimeError => e
-        puts 'WARNING: RF Gain is not supported by the radio backend.' if e.message.include?('Command: L RF_GAIN')
-        puts 'WARNING: Intermediate Gain is not supported by the radio backend.' if e.message.include?('Command: L IF_GAIN')
-        puts 'WARNING: Baseband Gain is not supported by the radio backend.' if e.message.include?('Command: L BB_GAIN')
+        response_str = 'Function not supported by this radio backend.' if e.message.include?('RF_GAIN') || e.message.include?('IF_GAIN') || e.message.include?('BB_GAIN')
 
-        raise e unless e.message.include?('Command: L RF_GAIN') ||
-                       e.message.include?('Command: L IF_GAIN') ||
-                       e.message.include?('Command: L BB_GAIN')
+        raise e unless e.message.include?('RF_GAIN') ||
+                       e.message.include?('IF_GAIN') ||
+                       e.message.include?('BB_GAIN')
       rescue StandardError => e
         raise e
       end
 
       # Supported Method Parameters::
       # strength_db = PWN::SDR::GQRX.measure_signal_strength(
-      #   gqrx_sock: 'required - GQRX socket object returned from #connect method'
+      #   gqrx_sock: 'required - GQRX socket object returned from #connect method',
+      #   freq: 'required - Frequency to measure signal strength',
+      #   strength_lock: 'optional - Strength lock in dBFS to determine signal edges (defaults to -70.0)',
+      #   phase: 'optional - Phase of measurement for logging purposes (defaults to :find_candidates)'
       # )
       private_class_method def self.measure_signal_strength(opts = {})
         gqrx_sock = opts[:gqrx_sock]
+        freq = opts[:freq].to_s.cast_to_raw_hz
+        freq = freq.to_i.cast_to_pretty_hz
+
+        strength_lock = opts[:strength_lock] ||= -70.0
+        phase = opts[:phase] ||= :find_candidates
 
+        attempts = 0
         strength_db = -99.9
-        prev_strength_db = strength_db
-        # While strength_db is rising, keep measuring
+        prev_strength_db = -99.9
+        distance_between_unique_samples = 0.0
+        samples = []
+        unique_samples = []
+        strength_measured = false
         loop do
+          attempts += 1
           strength_db = gqrx_cmd(gqrx_sock: gqrx_sock, cmd: 'l STRENGTH').to_f
-          print '$'
-          break if strength_db <= prev_strength_db
 
-          prev_strength_db = strength_db
+          # Fast approach while still maintaining decent accuracy
+          samples.push(strength_db)
+          unique_samples = samples.uniq
+          if unique_samples.length > 1
+            prev_strength_db = unique_samples[-2]
+            distance_between_unique_samples = (strength_db - prev_strength_db).abs
+            strength_measured = true if distance_between_unique_samples.positive? && strength_lock > strength_db
+          end
+          strength_measured = true if distance_between_unique_samples.positive? && distance_between_unique_samples < 5
+
+          break if strength_measured
+
+          # Sleep a tiny bit to allow strength_db values to fluctuate
           sleep 0.0001
         end
+        # Uncomment for debugging strength measurement attempts
+        # which translates to speed and accuracy refinement
+        puts "\tStrength Measurement Attempts: #{attempts} | Freq: #{freq} | Phase: #{phase} | Unique Samples: #{unique_samples} | dbFS Distance Unique Samples: #{distance_between_unique_samples}"
 
-        strength_db
+        strength_db.round(1)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # tune_resp = PWN::SDR::GQRX.tune_to(
+      #   gqrx_sock: 'required - GQRX socket object returned from #connect method',
+      #   hz: 'required - Frequency to tune to'
+      # )
+      private_class_method def self.tune_to(opts = {})
+        gqrx_sock = opts[:gqrx_sock]
+        hz = opts[:hz].to_s.cast_to_raw_hz
+
+        current_freq = 0
+        attempts = 0
+        loop do
+          attempts += 1
+          gqrx_cmd(
+            gqrx_sock: gqrx_sock,
+            cmd: "F #{hz}",
+            resp_ok: 'RPRT 0'
+          )
+
+          current_freq = gqrx_cmd(
+            gqrx_sock: gqrx_sock,
+            cmd: 'f'
+          )
+
+          break if current_freq.to_s.cast_to_raw_hz == hz
+        end
+        # puts "Tuned to #{current_freq} in #{attempts} attempt(s)."
       rescue StandardError => e
         raise e
       end
@@ -213,25 +264,22 @@ module PWN
         right_candidate_signals = []
         candidate_signals = []
 
-        # left_candidate_signals.clear
         original_hz = hz
         strength_db = 99.9
-        puts 'Finding Beginning Edge of Signal...'
+        puts '*** Edge Detection: Locating Beginning of Signal...'
         while strength_db >= strength_lock
-          gqrx_cmd(gqrx_sock: gqrx_sock, cmd: "F #{hz}")
-          current_freq = 0
-          while current_freq.to_s.cast_to_raw_hz != hz.to_s.cast_to_raw_hz
-            current_freq = gqrx_cmd(
-              gqrx_sock: gqrx_sock,
-              cmd: 'f'
-            )
-          end
-          strength_db = measure_signal_strength(gqrx_sock: gqrx_sock)
+          tune_to(gqrx_sock: gqrx_sock, hz: hz)
+          strength_db = measure_signal_strength(
+            gqrx_sock: gqrx_sock,
+            freq: hz,
+            strength_lock: strength_lock,
+            phase: :edge_left
+          )
           candidate = {
             hz: hz.to_s.cast_to_raw_hz,
             freq: hz.to_i.cast_to_pretty_hz,
             strength: strength_db,
-            side: :left
+            edge: :left
           }
           left_candidate_signals.push(candidate)
           hz -= step_hz
@@ -241,26 +289,23 @@ module PWN
 
         # Now scan forwards to find the end of the signal
         # The end of the signal is where the strength drops below strength_lock
-        # right_candidate_signals.clear
         hz = original_hz
 
         strength_db = 99.9
-        puts 'Finding Ending Edge of Signal...'
+        puts '*** Edge Detection: Locating End of Signal...'
         while strength_db >= strength_lock
-          gqrx_cmd(gqrx_sock: gqrx_sock, cmd: "F #{hz}")
-          current_freq = 0
-          while current_freq.to_s.cast_to_raw_hz != hz.to_s.cast_to_raw_hz
-            current_freq = gqrx_cmd(
-              gqrx_sock: gqrx_sock,
-              cmd: 'f'
-            )
-          end
-          strength_db = measure_signal_strength(gqrx_sock: gqrx_sock)
+          tune_to(gqrx_sock: gqrx_sock, hz: hz)
+          strength_db = measure_signal_strength(
+            gqrx_sock: gqrx_sock,
+            freq: hz,
+            strength_lock: strength_lock,
+            phase: :edge_right
+          )
           candidate = {
             hz: hz.to_s.cast_to_raw_hz,
             freq: hz.to_i.cast_to_pretty_hz,
             strength: strength_db,
-            side: :right
+            edge: :right
           }
           right_candidate_signals.push(candidate)
           hz += step_hz
@@ -292,7 +337,8 @@ module PWN
         signals.uniq! { |s| s[:freq].to_s.cast_to_raw_hz }
 
         timestamp_end = Time.now.strftime('%Y-%m-%d %H:%M:%S%z')
-        duration_secs = Time.parse(timestamp_end) - Time.parse(timestamp_start)
+        duration_secs = Time.parse(timestamp_end).to_f - Time.parse(timestamp_start).to_f
+
         # Convert duration seconds to hours minutes seconds
         hours = (duration_secs / 3600).to_i
         minutes = ((duration_secs % 3600) / 60).to_i
@@ -312,6 +358,10 @@ module PWN
           JSON.pretty_generate(scan_resp)
         )
 
+        # Append a new line at end of file to avoid readline
+        # issues requiring tput reset in terminal
+        File.write(scan_log, "\n", mode: 'a')
+
         scan_resp
       rescue StandardError => e
         raise e
@@ -340,7 +390,7 @@ module PWN
 
         rds_resp = {}
         attempts = 0
-        max_attempts = 90
+        max_attempts = 120
         skip_rds = "\n"
         print 'INFO: Decoding FM radio RDS data (Press ENTER to skip)...'
         max_attempts.times do
@@ -365,6 +415,115 @@ module PWN
         raise e
       end
 
+      # Supported Method Parameters::
+      # best_peak = PWN::SDR::GQRX.find_best_peak(
+      #   gqrx_sock: 'required - GQRX socket object returned from #connect method',
+      #   candidate_signals: 'required - Array of candidate signals from edge_detection',
+      #   step_hz: 'required - Frequency step in Hz for peak finding',
+      #   strength_lock: 'required - Strength lock in dBFS to determine signal edges'
+      # )
+      private_class_method def self.find_best_peak(opts = {})
+        gqrx_sock = opts[:gqrx_sock]
+        candidate_signals = opts[:candidate_signals]
+        step_hz = opts[:step_hz]
+        strength_lock = opts[:strength_lock]
+
+        beg_of_signal_hz = candidate_signals.first[:hz].to_s.cast_to_raw_hz
+        end_of_signal_hz = candidate_signals.last[:hz].to_s.cast_to_raw_hz
+
+        puts "*** Analyzing Best Peak in Frequency Range: #{beg_of_signal_hz.to_i.cast_to_pretty_hz} Hz - #{end_of_signal_hz.to_i.cast_to_pretty_hz} Hz"
+        # puts JSON.pretty_generate(candidate_signals)
+
+        samples = []
+        prev_best_sample = {}
+        consecutive_best = 0
+        direction_up = true
+
+        pass_count = 0
+        infinite_loop_safeguard = false
+        while true
+          pass_count += 1
+
+          # Safeguard against infinite loop
+          # infinite_loop_safeguard = true if pass_count >= 100
+          infinite_loop_safeguard = true if pass_count >= 10
+          puts 'WARNING: Infinite loop safeguard triggered in find_best_peak!' if infinite_loop_safeguard
+          break if infinite_loop_safeguard
+
+          direction_up = !direction_up
+          start_hz_direction = direction_up ? beg_of_signal_hz : end_of_signal_hz
+          end_hz_direction = direction_up ? end_of_signal_hz : beg_of_signal_hz
+          step_hz_direction = direction_up ? step_hz : -step_hz
+
+          start_hz_direction.step(by: step_hz_direction, to: end_hz_direction) do |hz|
+            print '>' if direction_up
+            print '<' unless direction_up
+            tune_to(gqrx_sock: gqrx_sock, hz: hz)
+            strength_db = measure_signal_strength(
+              gqrx_sock: gqrx_sock,
+              freq: hz,
+              strength_lock: strength_lock,
+              phase: :find_best_peak
+            )
+            samples.push({ hz: hz, strength_db: strength_db })
+
+            # current_hz = gqrx_cmd(gqrx_sock: gqrx_sock, cmd: 'f').to_s.cast_to_raw_hz
+            # puts "Sampled Frequency: #{current_hz.to_i.cast_to_pretty_hz} => Strength: #{strength_db} dBFS"
+          end
+
+          # Compute fresh averaged_samples from all cumulative samples
+          averaged_samples = []
+          samples.group_by { |s| s[:hz] }.each do |hz, grouped_samples|
+            avg_strength = (grouped_samples.map { |s| s[:strength_db] }.sum / grouped_samples.size)
+            averaged_samples.push({ hz: hz, strength_db: avg_strength })
+          end
+
+          # Sort by hz for trimming
+          averaged_samples.sort_by! { |s| s[:hz] }
+
+          # Find current best for trimming threshold
+          best_sample = averaged_samples.max_by { |s| s[:strength_db] }
+          max_strength = best_sample[:strength_db].round(1)
+
+          # trim_db_threshold should bet average difference between
+          # samples near peak, floor to nearest 0.1 dB
+          trim_db_threshold = samples.map { |s| (s[:strength_db] - max_strength).abs }.sum / samples.size
+          trim_db_threshold = (trim_db_threshold * 10).floor / 10.0
+          puts "\nPass #{pass_count}: Calculated trim_db_threshold: #{trim_db_threshold} dB"
+          # Adaptive trim: Remove weak ends (implements the comment about trimming weakest ends)
+          averaged_samples.shift while !averaged_samples.empty? && averaged_samples.first[:strength_db] < max_strength - trim_db_threshold
+          averaged_samples.pop while !averaged_samples.empty? && averaged_samples.last[:strength_db] < max_strength - trim_db_threshold
+
+          # Update range for next pass if trimmed
+          unless averaged_samples.empty?
+            beg_of_signal_hz = averaged_samples.first[:hz]
+            end_of_signal_hz = averaged_samples.last[:hz]
+          end
+
+          # Recalculate best_sample after trim
+          best_sample = averaged_samples.max_by { |s| s[:strength_db] }
+
+          # Check for improvement
+          if best_sample[:hz] == prev_best_sample[:hz]
+            consecutive_best += 1
+          else
+            consecutive_best = 0
+          end
+
+          # Dup to avoid reference issues
+          prev_best_sample = best_sample.dup
+
+          puts "Pass #{pass_count}: Best #{best_sample[:hz].to_i.cast_to_pretty_hz} => #{best_sample[:strength_db]} dBFS, consecutive best count: #{consecutive_best}"
+
+          # Break if we have a stable best sample or only one sample remains
+          break if consecutive_best.positive? || averaged_samples.length == 1
+        end
+
+        best_sample
+      rescue StandardError => e
+        raise e
+      end
+
       # Supported Method Parameters::
       # gqrx_sock = PWN::SDR::GQRX.connect(
       #   target: 'optional - GQRX target IP address (defaults to 127.0.0.1)',
@@ -385,7 +544,7 @@ module PWN
       #   freq: 'required - Frequency to set',
       #   demodulator_mode: 'optional - Demodulator mode (defaults to WFM)',
       #   rds: 'optional - Boolean to enable/disable RDS decoding (defaults to false)',
-      #   bandwidth: 'optional - Bandwidth (defaults to 200_000)',
+      #   bandwidth: 'optional - Bandwidth (defaults to "200.000")',
       #   squelch: 'optional - Squelch level to set (Defaults to current value)',
       #   decoder: 'optional - Decoder key (e.g., :gsm) to start live decoding (starts recording if provided)',
       #   record_dir: 'optional - Directory where GQRX saves recordings (required if decoder provided; defaults to /tmp/gqrx_recordings)',
@@ -415,7 +574,7 @@ module PWN
 
         rds = opts[:rds] ||= false
 
-        bandwidth = opts[:bandwidth] ||= 200_000
+        bandwidth = opts[:bandwidth] ||= '200.000'
         squelch = opts[:squelch]
         decoder = opts[:decoder]
         record_dir = opts[:record_dir] ||= '/tmp'
@@ -441,25 +600,19 @@ module PWN
           )
         end
 
-        change_freq_resp = gqrx_cmd(
+        tune_to(gqrx_sock: gqrx_sock, hz: freq)
+        strength_db = measure_signal_strength(
           gqrx_sock: gqrx_sock,
-          cmd: "F #{freq.to_s.cast_to_raw_hz}",
-          resp_ok: 'RPRT 0'
+          freq: freq,
+          phase: :init_freq
         )
 
-        current_freq = 0
-        while current_freq.to_s.cast_to_raw_hz != freq.to_s.cast_to_raw_hz
-          current_freq = gqrx_cmd(
-            gqrx_sock: gqrx_sock,
-            cmd: 'f'
-          )
-        end
-
         freq_obj = {
-          bandwidth: bandwidth,
+          freq: freq,
           demodulator_mode: demodulator_mode,
+          bandwidth: bandwidth,
           rds: rds,
-          freq: freq
+          strength_db: strength_db
         }
 
         unless suppress_details
@@ -473,8 +626,6 @@ module PWN
             cmd: 'l AF'
           ).to_f
 
-          strength_db = measure_signal_strength(gqrx_sock: gqrx_sock)
-
           squelch = gqrx_cmd(
             gqrx_sock: gqrx_sock,
             cmd: 'l SQL'
@@ -504,7 +655,6 @@ module PWN
           freq_obj[:if_gain] = if_gain
           freq_obj[:rf_gain] = rf_gain
           freq_obj[:squelch] = squelch
-          freq_obj[:strength_db] = strength_db
           freq_obj[:rds] = rds_resp
         end
 
@@ -571,7 +721,7 @@ module PWN
       #   target_freq: 'required - Target frequency of scan range',
       #   demodulator_mode: 'optional - Demodulator mode (e.g. WFM, AM, FM, USB, LSB, RAW, CW, RTTY / defaults to WFM)',
       #   rds: 'optional - Boolean to enable/disable RDS decoding (defaults to false)',
-      #   bandwidth: 'optional - Bandwidth in Hz (Defaults to 200_000)',
+      #   bandwidth: 'optional - Bandwidth in Hz (Defaults to "200.000")',
       #   precision: 'optional - Frequency step precision (number of digits; defaults to 1)',
       #   strength_lock: 'optional - Strength lock in dBFS (defaults to -70.0)',
       #   squelch: 'optional - Squelch level in dBFS (defaults to strength_lock - 3.0)',
@@ -598,7 +748,8 @@ module PWN
         demodulator_mode = opts[:demodulator_mode]
         rds = opts[:rds] ||= false
 
-        bandwidth = opts[:bandwidth] ||= 200_000
+        bandwidth = opts[:bandwidth] ||= '200.000'
+
         precision = opts[:precision] ||= 1
         strength_lock = opts[:strength_lock] ||= -70.0
         squelch = opts[:squelch] ||= (strength_lock - 3.0)
@@ -606,7 +757,7 @@ module PWN
         location = opts[:location] ||= 'United States'
 
         step_hz = 10**(precision - 1)
-        step = hz_start > hz_target ? -step_hz : step_hz
+        step_hz_direction = hz_start > hz_target ? -step_hz : step_hz
 
         # Set squelch once for the scan
         change_squelch_resp = gqrx_cmd(
@@ -680,100 +831,10 @@ module PWN
 
         candidate_signals = []
 
-        # Adaptive peak finder – trims weakest ends after each pass
-        # Converges quickly to the true center of the bell curve
-        find_best_peak = lambda do |opts = {}|
-          beg_of_signal_hz = opts[:beg_of_signal_hz].to_s.cast_to_raw_hz
-          end_of_signal_hz = opts[:end_of_signal_hz].to_s.cast_to_raw_hz
-
-          samples = []
-          prev_best_sample = {}
-          consecutive_best = 0
-          direction_up = true
-
-          pass_count = 0
-          infinite_loop_safeguard = false
-          while true
-            pass_count += 1
-
-            # Safeguard against infinite loop
-            infinite_loop_safeguard = true if pass_count >= 100
-            puts 'WARNING: Infinite loop safeguard triggered in find_best_peak!' if infinite_loop_safeguard
-            break if infinite_loop_safeguard
-
-            direction_up = !direction_up
-            start_hz_direction = direction_up ? beg_of_signal_hz : end_of_signal_hz
-            end_hz_direction = direction_up ? end_of_signal_hz : beg_of_signal_hz
-            step_hz_direction = direction_up ? step_hz : -step_hz
-
-            start_hz_direction.step(by: step_hz_direction, to: end_hz_direction) do |hz|
-              print '>' if direction_up
-              print '<' unless direction_up
-              gqrx_cmd(gqrx_sock: gqrx_sock, cmd: "F #{hz}")
-              strength_db = measure_signal_strength(gqrx_sock: gqrx_sock)
-              samples.push({ hz: hz, strength_db: strength_db })
-
-              # current_hz = gqrx_cmd(gqrx_sock: gqrx_sock, cmd: 'f').to_s.cast_to_raw_hz
-              # puts "Sampled Frequency: #{current_hz.to_i.cast_to_pretty_hz} => Strength: #{strength_db} dBFS"
-            end
-
-            # Compute fresh averaged_samples from all cumulative samples
-            averaged_samples = []
-            samples.group_by { |s| s[:hz] }.each do |hz, grouped_samples|
-              avg_strength = (grouped_samples.map { |s| s[:strength_db] }.sum / grouped_samples.size)
-              # avg_strength = (grouped_samples.map { |s| s[:strength_db] }.sum / grouped_samples.size).round(2)
-              # avg_strength = (grouped_samples.map { |s| s[:strength_db] }.sum / grouped_samples.size).round(1)
-              averaged_samples.push({ hz: hz, strength_db: avg_strength })
-            end
-
-            # Sort by hz for trimming
-            averaged_samples.sort_by! { |s| s[:hz] }
-
-            # Find current best for trimming threshold
-            best_sample = averaged_samples.max_by { |s| s[:strength_db] }
-            max_strength = best_sample[:strength_db]
-
-            # trim_db_threshold should bet average difference between
-            # samples near peak, floor to nearest 0.1 dB
-            trim_db_threshold = samples.map { |s| (s[:strength_db] - max_strength).abs }.sum / samples.size
-            trim_db_threshold = (trim_db_threshold * 10).floor / 10.0
-            puts "\nPass #{pass_count}: Calculated trim_db_threshold: #{trim_db_threshold} dB"
-            # Adaptive trim: Remove weak ends (implements the comment about trimming weakest ends)
-            averaged_samples.shift while !averaged_samples.empty? && averaged_samples.first[:strength_db] < max_strength - trim_db_threshold
-            averaged_samples.pop while !averaged_samples.empty? && averaged_samples.last[:strength_db] < max_strength - trim_db_threshold
-
-            # Update range for next pass if trimmed
-            unless averaged_samples.empty?
-              beg_of_signal_hz = averaged_samples.first[:hz]
-              end_of_signal_hz = averaged_samples.last[:hz]
-            end
-
-            # Recalculate best_sample after trim
-            best_sample = averaged_samples.max_by { |s| s[:strength_db] }
-
-            # Check for improvement
-            if best_sample[:hz] == prev_best_sample[:hz]
-              consecutive_best += 1
-            else
-              consecutive_best = 0
-            end
-
-            # Dup to avoid reference issues
-            prev_best_sample = best_sample.dup
-
-            puts "Pass #{pass_count}: Best #{best_sample[:hz].to_i.cast_to_pretty_hz} => #{best_sample[:strength_db]} dBFS, consecutive best count: #{consecutive_best}"
-
-            # Break if no improvement in 3 consecutive passes or theres only one sample left
-            break if consecutive_best.positive? || averaged_samples.size == 1
-          end
-
-          best_sample
-        end
-
         # Begin scanning range
         puts "\n"
         puts '-' * 86
-        puts "INFO: Scanning from #{hz_start.to_i.cast_to_pretty_hz} to #{hz_target.to_i.cast_to_pretty_hz} in steps of #{step.abs.to_i.cast_to_pretty_hz} Hz."
+        puts "INFO: Scanning from #{hz_start.to_i.cast_to_pretty_hz} to #{hz_target.to_i.cast_to_pretty_hz} in steps of #{step_hz_direction.abs.to_i.cast_to_pretty_hz} Hz."
         puts "If scans are slow and/or you're experiencing false positives/negatives,"
         puts 'consider adjusting the following:'
         puts "1. The SDR's sample rate in GQRX"
@@ -788,17 +849,15 @@ module PWN
 
         signals_arr = []
         hz = hz_start
-        while hz <= hz_target
-          gqrx_cmd(gqrx_sock: gqrx_sock, cmd: "F #{hz}")
-          current_freq = 0
-          while current_freq.to_s.cast_to_raw_hz != hz.to_s.cast_to_raw_hz
-            current_freq = gqrx_cmd(
-              gqrx_sock: gqrx_sock,
-              cmd: 'f'
-            )
-          end
 
-          strength_db = measure_signal_strength(gqrx_sock: gqrx_sock)
+        while step_hz_direction.positive? ? hz <= hz_target : hz >= hz_target
+          tune_to(gqrx_sock: gqrx_sock, hz: hz)
+          strength_db = measure_signal_strength(
+            gqrx_sock: gqrx_sock,
+            freq: hz,
+            strength_lock: strength_lock,
+            phase: :find_candidates
+          )
 
           if strength_db >= strength_lock
             puts '-' * 86
@@ -810,23 +869,11 @@ module PWN
               strength_lock: strength_lock
             )
           elsif candidate_signals.length.positive?
-            beg_of_signal_hz = candidate_signals.first[:hz]
-            top_of_signal_hz_idx = (candidate_signals.length - 1) / 2
-            top_of_signal_hz = candidate_signals[top_of_signal_hz_idx][:hz]
-            end_of_signal_hz = candidate_signals.last[:hz]
-            puts 'Candidate Signal(s) Detected:'
-            puts JSON.pretty_generate(candidate_signals)
-
-            prev_freq = prev_freq_obj[:freq].to_s.cast_to_raw_hz
-            distance_from_prev_detected_freq_hz = (beg_of_signal_hz - prev_freq).abs
-            half_bandwidth = (bandwidth / 2).to_i
-
-            puts "Key Frequencies: Begin: #{beg_of_signal_hz.to_i.cast_to_pretty_hz} Hz | Estimated Top: #{top_of_signal_hz.to_i.cast_to_pretty_hz} Hz | End: #{end_of_signal_hz.to_i.cast_to_pretty_hz} Hz"
-
-            puts 'Finding Best Peak...'
-            best_peak = find_best_peak.call(
-              beg_of_signal_hz: beg_of_signal_hz,
-              end_of_signal_hz: end_of_signal_hz
+            best_peak = find_best_peak(
+              gqrx_sock: gqrx_sock,
+              candidate_signals: candidate_signals,
+              step_hz: step_hz,
+              strength_lock: strength_lock
             )
 
             if best_peak[:hz] && best_peak[:strength_db] > strength_lock
@@ -860,12 +907,12 @@ module PWN
                 timestamp_start: timestamp_start,
                 scan_log: scan_log
               )
-              hz = end_of_signal_hz
+              hz = candidate_signals.last[:hz]
               # gets
             end
             candidate_signals.clear
           end
-          hz += step_hz
+          hz += step_hz_direction
         end
 
         log_signals(
@@ -978,7 +1025,7 @@ module PWN
             freq: 'required - Frequency to set',
             demodulator_mode: 'optional - Demodulator mode (defaults to WFM)',
             rds: 'optional - Boolean to enable/disable RDS decoding (defaults to false)',
-            bandwidth: 'optional - Bandwidth (defaults to 200_000)',
+            bandwidth: 'optional - Bandwidth (defaults to \"200.000\")',
             decoder: 'optional - Decoder key (e.g., :gsm) to start live decoding (starts recording if provided)',
             record_dir: 'optional - Directory where GQRX saves recordings (required if decoder provided; defaults to /tmp/gqrx_recordings)',
             suppress_details: 'optional - Boolean to include extra frequency details in return hash (defaults to false)',
@@ -990,7 +1037,7 @@ module PWN
             start_freq: 'required - Starting frequency',
             target_freq: 'required - Target frequency',
             demodulator_mode: 'optional - Demodulator mode (e.g. WFM, AM, FM, USB, LSB, RAW, CW, RTTY / defaults to WFM)',
-            bandwidth: 'optional - Bandwidth in Hz (Defaults to 200_000)',
+            bandwidth: 'optional - Bandwidth in Hz (Defaults to \"200.000\")',
             precision: 'optional - Precision (Defaults to 1)',
             strength_lock: 'optional - Strength lock (defaults to -70.0)',
             squelch: 'optional - Squelch level (defaults to strength_lock - 3.0)',

data/lib/pwn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PWN
-  VERSION = '0.5.514'
+  VERSION = '0.5.516'
 end