pwn 0.5.515 → 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
@@ -158,13 +158,11 @@ 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
@@ -172,36 +170,49 @@ module PWN
       # Supported Method Parameters::
       # strength_db = PWN::SDR::GQRX.measure_signal_strength(
       #   gqrx_sock: 'required - GQRX socket object returned from #connect method',
-      #   strength_lock: 'optional - Strength lock in dBFS to determine signal edges (defaults to -70.0)'
+      #   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 = -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
 
-          # Suprisingly accurate but takes longer
-          # `break if strength_db < prev_strength_db` || attempts >= 300
-          # is VERY accurate with
-          # `sleep 0.0001`
-          # but with more sampling == longer time
-          # break if attempts >= 100 && (strength_lock > strength_db || strength_db < prev_strength_db)
-
-          break if attempts >= 30 && strength_lock > 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 attempts >= 300 || strength_db < prev_strength_db
+          break if strength_measured
 
-          sleep 0.001
-          prev_strength_db = strength_db
+          # Sleep a tiny bit to allow strength_db values to fluctuate
+          sleep 0.0001
         end
-        puts "Strength Measurement Attempts: #{attempts}"
+        # 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
@@ -253,21 +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
           tune_to(gqrx_sock: gqrx_sock, hz: hz)
           strength_db = measure_signal_strength(
             gqrx_sock: gqrx_sock,
-            strength_lock: strength_lock
+            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
@@ -277,22 +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
           tune_to(gqrx_sock: gqrx_sock, hz: hz)
           strength_db = measure_signal_strength(
             gqrx_sock: gqrx_sock,
-            strength_lock: strength_lock
+            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
@@ -324,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
@@ -344,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
@@ -372,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
@@ -397,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)',
@@ -417,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)',
@@ -447,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'
@@ -475,15 +602,17 @@ module PWN
 
         tune_to(gqrx_sock: gqrx_sock, hz: freq)
         strength_db = measure_signal_strength(
-          gqrx_sock: gqrx_sock
+          gqrx_sock: gqrx_sock,
+          freq: freq,
+          phase: :init_freq
         )
 
         freq_obj = {
-          bandwidth: bandwidth,
+          freq: freq,
           demodulator_mode: demodulator_mode,
+          bandwidth: bandwidth,
           rds: rds,
-          strength_db: strength_db,
-          freq: freq
+          strength_db: strength_db
         }
 
         unless suppress_details
@@ -592,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)',
@@ -619,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)
@@ -627,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(
@@ -701,103 +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
-              tune_to(gqrx_sock: gqrx_sock, hz: hz)
-              strength_db = measure_signal_strength(
-                gqrx_sock: gqrx_sock,
-                strength_lock: strength_lock
-              )
-              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"
@@ -812,11 +849,14 @@ module PWN
 
         signals_arr = []
         hz = hz_start
-        while hz <= hz_target
+
+        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,
-            strength_lock: strength_lock
+            freq: hz,
+            strength_lock: strength_lock,
+            phase: :find_candidates
           )
 
           if strength_db >= strength_lock
@@ -829,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
@@ -879,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(
@@ -997,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)',
@@ -1009,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.515'
+  VERSION = '0.5.516'
 end

data/third_party/pwn_rdoc.jsonl

@@ -1292,14 +1292,18 @@
 {"messages":[{"role":"user","content":"PWN::SDR::GQRX.analyze_scan Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.analyze_scan`: Supported Method Parameters\n\nPWN::SDR::GQRX.analyze_scan(\n\nscan_resp: 'required - Scan response hash returned from #scan_range method',\ntarget: 'optional - GQRX target IP address (defaults to 127.0.0.1)',\nport: 'optional - GQRX target port (defaults to 7356)'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::SDR::GQRX.authors Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.authors`: Author(s)\n\n0day Inc. <support@0dayinc.com>\n"}]}
 {"messages":[{"role":"user","content":"PWN::SDR::GQRX.connect Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.connect`: Supported Method Parameters\n\ngqrx_sock = PWN::SDR::GQRX.connect(\n\ntarget: 'optional - GQRX target IP address (defaults to 127.0.0.1)',\nport: 'optional - GQRX target port (defaults to 7356)'\n\n)\n"}]}
+{"messages":[{"role":"user","content":"PWN::SDR::GQRX.decode_rds Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.decode_rds`: Supported Method Parameters\n\nrds_resp = PWN::SDR::GQRX.decode_rds(\n\ngqrx_sock: 'required - GQRX socket object returned from #connect method'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::SDR::GQRX.disconnect Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.disconnect`: Supported Method Parameters\n\nPWN::SDR::GQRX.disconnect(\n\ngqrx_sock: 'required - GQRX socket object returned from #connect method'\n\n)\n"}]}
+{"messages":[{"role":"user","content":"PWN::SDR::GQRX.edge_detection Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.edge_detection`: Supported Method Parameters\n\ncandidate_signals = PWN::SDR::GQRX.edge_detection(\n\ngqrx_sock: 'required - GQRX socket object returned from #connect method',\nhz: 'required - Frequency to start edge detection from',\nstep_hz: 'required - Frequency step in Hz for edge detection',\nstrength_lock: 'required - Strength lock in dBFS to determine signal edges'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::SDR::GQRX.gqrx_cmd Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.gqrx_cmd`: Supported Method Parameters\n\ngqrx_resp = PWN::SDR::GQRX.gqrx_cmd(\n\ngqrx_sock: 'required - GQRX socket object returned from #connect method',\ncmd: 'required - GQRX command to execute',\nresp_ok: 'optional - Expected response from GQRX to indicate success'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::SDR::GQRX.help Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.help`: "}]}
-{"messages":[{"role":"user","content":"PWN::SDR::GQRX.init_freq Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.init_freq`: Supported Method Parameters\n\nfreq_obj = PWN::SDR::GQRX.init_freq(\n\ngqrx_sock: 'required - GQRX socket object returned from #connect method',\nfreq: 'required - Frequency to set',\ndemodulator_mode: 'optional - Demodulator mode (defaults to WFM)',\nbandwidth: 'optional - Bandwidth (defaults to 200_000)',\nsquelch: 'optional - Squelch level to set (Defaults to current value)',\ndecoder: 'optional - Decoder key (e.g., :gsm) to start live decoding (starts recording if provided)',\nrecord_dir: 'optional - Directory where GQRX saves recordings (required if decoder provided; defaults to /tmp/gqrx_recordings)',\nsuppress_details: 'optional - Boolean to include extra frequency details in return hash (defaults to false)',\nkeep_alive: 'optional - Boolean to keep GQRX connection alive after method completion (defaults to false)'\n\n)\n"}]}
+{"messages":[{"role":"user","content":"PWN::SDR::GQRX.init_freq Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.init_freq`: Supported Method Parameters\n\nfreq_obj = PWN::SDR::GQRX.init_freq(\n\ngqrx_sock: 'required - GQRX socket object returned from #connect method',\nfreq: 'required - Frequency to set',\ndemodulator_mode: 'optional - Demodulator mode (defaults to WFM)',\nrds: 'optional - Boolean to enable/disable RDS decoding (defaults to false)',\nbandwidth: 'optional - Bandwidth (defaults to 200_000)',\nsquelch: 'optional - Squelch level to set (Defaults to current value)',\ndecoder: 'optional - Decoder key (e.g., :gsm) to start live decoding (starts recording if provided)',\nrecord_dir: 'optional - Directory where GQRX saves recordings (required if decoder provided; defaults to /tmp/gqrx_recordings)',\nsuppress_details: 'optional - Boolean to include extra frequency details in return hash (defaults to false)',\nkeep_alive: 'optional - Boolean to keep GQRX connection alive after method completion (defaults to false)'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::SDR::GQRX.log_signals Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.log_signals`: Supported Method Parameters\n\nscan_resp = PWN::SDR::GQRX.log_signals(\n\nsignals_arr: 'required - Array of detected signals',\ntimestamp_start: 'required - Scan start timestamp',\nscan_log: 'required - Path to save detected signals log'\n\n)\n"}]}
-{"messages":[{"role":"user","content":"PWN::SDR::GQRX.scan_range Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.scan_range`: Supported Method Parameters\n\nscan_resp = PWN::SDR::GQRX.scan_range(\n\ngqrx_sock: 'required - GQRX socket object returned from #connect method',\nstart_freq: 'required - Start frequency of scan range',\ntarget_freq: 'required - Target frequency of scan range',\ndemodulator_mode: 'optional - Demodulator mode (e.g. WFM, AM, FM, USB, LSB, RAW, CW, RTTY / defaults to WFM)',\nbandwidth: 'optional - Bandwidth in Hz (Defaults to 200_000)',\noverlap_protection: 'optional - Boolean to enable/disable bandwidth overlap protection (defaults to false)',\nprecision: 'optional - Frequency step precision (number of digits; defaults to 1)',\nlock_freq_duration: 'optional - Lock frequency duration in seconds (defaults to 0.04)',\nstrength_lock: 'optional - Strength lock in dBFS (defaults to -70.0)',\nsquelch: 'optional - Squelch level in dBFS (defaults to strength_lock - 3.0)',\naudio_gain_db: 'optional - Audio gain in dB (defaults to 6.0)',\nrf_gain: 'optional - RF gain (defaults to 0.0)',\nintermediate_gain: 'optional - Intermediate gain (defaults to 32.0)',\nbaseband_gain: 'optional - Baseband gain (defaults to 10.0)',\nscan_log: 'optional - Path to save detected signals log (defaults to /tmp/pwn_sdr_gqrx_scan_<start_freq>-<target_freq>_<timestamp>.json)',\nlocation: 'optional - Location string to include in AI analysis (e.g., \"New York, NY\", 90210, GPS coords, etc.)'\n\n)\n"}]}
-{"messages":[{"role":"user","content":"PWN::SDR::GQRX.pretty_hz Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.pretty_hz`: "}]}
-{"messages":[{"role":"user","content":"PWN::SDR::GQRX.raw_hz Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.raw_hz`: "}]}
+{"messages":[{"role":"user","content":"PWN::SDR::GQRX.measure_signal_strength Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.measure_signal_strength`: Supported Method Parameters\n\nstrength_db = PWN::SDR::GQRX.measure_signal_strength(\n\ngqrx_sock: 'required - GQRX socket object returned from #connect method',\nstrength_lock: 'optional - Strength lock in dBFS to determine signal edges (defaults to -70.0)'\n\n)\n"}]}
+{"messages":[{"role":"user","content":"PWN::SDR::GQRX.scan_range Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.scan_range`: Supported Method Parameters\n\nscan_resp = PWN::SDR::GQRX.scan_range(\n\ngqrx_sock: 'required - GQRX socket object returned from #connect method',\nstart_freq: 'required - Start frequency of scan range',\ntarget_freq: 'required - Target frequency of scan range',\ndemodulator_mode: 'optional - Demodulator mode (e.g. WFM, AM, FM, USB, LSB, RAW, CW, RTTY / defaults to WFM)',\nrds: 'optional - Boolean to enable/disable RDS decoding (defaults to false)',\nbandwidth: 'optional - Bandwidth in Hz (Defaults to 200_000)',\nprecision: 'optional - Frequency step precision (number of digits; defaults to 1)',\nstrength_lock: 'optional - Strength lock in dBFS (defaults to -70.0)',\nsquelch: 'optional - Squelch level in dBFS (defaults to strength_lock - 3.0)',\naudio_gain_db: 'optional - Audio gain in dB (defaults to 6.0)',\nrf_gain: 'optional - RF gain (defaults to 0.0)',\nintermediate_gain: 'optional - Intermediate gain (defaults to 32.0)',\nbaseband_gain: 'optional - Baseband gain (defaults to 10.0)',\nscan_log: 'optional - Path to save detected signals log (defaults to /tmp/pwn_sdr_gqrx_scan_<start_freq>-<target_freq>_<timestamp>.json)',\nlocation: 'optional - Location string to include in AI analysis (e.g., \"New York, NY\", 90210, GPS coords, etc.)'\n\n)\n"}]}
+{"messages":[{"role":"user","content":"PWN::SDR::GQRX.tune_to Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.tune_to`: Supported Method Parameters\n\ntune_resp = PWN::SDR::GQRX.tune_to(\n\ngqrx_sock: 'required - GQRX socket object returned from #connect method',\nhz: 'required - Frequency to tune to'\n\n)\n"}]}
+{"messages":[{"role":"user","content":"PWN::SDR::GQRX.cast_to_pretty_hz Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.cast_to_pretty_hz`: "}]}
+{"messages":[{"role":"user","content":"PWN::SDR::GQRX.cast_to_raw_hz Usage"},{"role":"assistant","content":"`PWN::SDR::GQRX.cast_to_raw_hz`: "}]}
 {"messages":[{"role":"user","content":"PWN::SDR::RFIDler.authors Usage"},{"role":"assistant","content":"`PWN::SDR::RFIDler.authors`: Author(s)\n\n0day Inc. <support@0dayinc.com>\n"}]}
 {"messages":[{"role":"user","content":"PWN::SDR::RFIDler.connect_via_screen Usage"},{"role":"assistant","content":"`PWN::SDR::RFIDler.connect_via_screen`: Supported Method Parameters\n\nPWN::SDR::RFIDler.connect_via_screen(\n\nblock_dev: 'optional - serial block device path (defaults to /dev/ttyUSB0)'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::SDR::RFIDler.help Usage"},{"role":"assistant","content":"`PWN::SDR::RFIDler.help`: "}]}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.515
+  version: 0.5.516
 platform: ruby
 authors:
 - 0day Inc.
@@ -869,14 +869,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.0.1
+        version: 7.0.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.0.1
+        version: 7.0.2
 - !ruby/object:Gem::Dependency
   name: rest-client
   requirement: !ruby/object:Gem::Requirement