rtlsdr 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdda82a845fb18a7c4e62aa92047ed89c380ff8cb4eeb09c0d67791fd6504fc2
-  data.tar.gz: 4427f96657f4c5be7e36693fc1c217ed138caf89128d3203201d4c76dbfc5599
+  metadata.gz: 1b12c3758778bb23282dd45b6fd7a7875ab966902921da11a01e20e091e695f3
+  data.tar.gz: 9d89756d0d0777d2f60e650809c38c5aad56a33e115e873e6557bb5586720b02
 SHA512:
-  metadata.gz: fa87ae066f74a465ba70b33ad0ec5d0619abd698216911325754182e2bfb6b6a872aef24e82d430ebea12a304b342fbf007d5afbe36464011ee9f4806bd844e1
-  data.tar.gz: 96b90536e0c46f750ae06d22ff5608dbfdfeb06879221f7ada51c5ec2c50560029744d8296c170a69173c33e4e07e472bdc64ca96e1ed475736e19affdb62835
+  metadata.gz: 57cfd89abe99c55d86e66e3fee3b0da12da94f6feceab7860be79871cd9611bf31ce3f9a2fb8235f1cb2f5ae06bb353df56c3bae3df5c2b4f3affc0267d3bce9
+  data.tar.gz: 1f9c2f119f049eaa84aff2c4afbef95854ebcd3a241441d0676a0f9220b064730b91ee6e95b7d6afbbcdfc40e673418de1f8a70ae1ffea041a65bde26b7c047c

data/README.md

@@ -289,6 +289,22 @@ audio = RTLSDR::Demod.usb(samples, sample_rate: 2_048_000, bfo_offset: 1500)
 audio = RTLSDR::Demod.lsb(samples, sample_rate: 2_048_000, bfo_offset: 1500)
 ```
 
+### FSK Demodulation
+
+```ruby
+# Demodulate FSK signal at 1200 baud
+bits = RTLSDR::Demod.fsk(samples, sample_rate: 48_000, baud_rate: 1200)
+
+# RTTY at 45.45 baud
+bits = RTLSDR::Demod.fsk(samples, sample_rate: 48_000, baud_rate: 45.45)
+
+# Invert mark/space if needed
+bits = RTLSDR::Demod.fsk(samples, sample_rate: 48_000, baud_rate: 1200, invert: true)
+
+# Get raw discriminator output for debugging/visualization
+waveform = RTLSDR::Demod.fsk_raw(samples, sample_rate: 48_000, baud_rate: 1200)
+```
+
 ### Helper Functions
 
 ```ruby
@@ -542,6 +558,11 @@ ruby examples/spectrum_analyzer.rb
 - `Demod.usb(samples, sample_rate:, audio_rate:, bfo_offset:)` - Upper Sideband
 - `Demod.lsb(samples, sample_rate:, audio_rate:, bfo_offset:)` - Lower Sideband
 
+#### FSK Demodulation
+
+- `Demod.fsk(samples, sample_rate:, baud_rate:, invert:)` - FSK to bits
+- `Demod.fsk_raw(samples, sample_rate:, baud_rate:)` - Raw discriminator output
+
 #### Helper Functions
 
 - `Demod.complex_oscillator(length, frequency, sample_rate)` - Generate carrier

data/lib/rtlsdr/demod.rb

@@ -363,6 +363,111 @@ module RTLSDR
       normalize_audio(audio)
     end
 
+    # =========================================================================
+    # FSK Demodulation
+    # =========================================================================
+
+    # FSK (Frequency Shift Keying) demodulation
+    #
+    # Demodulates FSK signals by using an FM discriminator to extract
+    # instantaneous frequency, then thresholding to recover bits.
+    # FSK encodes data by switching between two frequencies (mark and space).
+    #
+    # @param [Array<Complex>] samples Input IQ samples
+    # @param [Integer] sample_rate Input sample rate in Hz
+    # @param [Numeric] baud_rate Symbol rate in baud (symbols per second)
+    # @param [Boolean] invert Swap mark/space interpretation (default: false)
+    # @return [Array<Integer>] Recovered bits (0 or 1)
+    # @example Demodulate 1200 baud FSK
+    #   bits = RTLSDR::Demod.fsk(samples, sample_rate: 48_000, baud_rate: 1200)
+    # @example Demodulate RTTY at 45.45 baud
+    #   bits = RTLSDR::Demod.fsk(samples, sample_rate: 48_000, baud_rate: 45.45)
+    def self.fsk(samples, sample_rate:, baud_rate:, invert: false)
+      return [] if samples.empty? || samples.length < 2
+
+      # Step 1: FM discriminator to get instantaneous frequency
+      freq = phase_diff(samples)
+      return [] if freq.empty?
+
+      # Step 2: Lowpass filter to smooth transitions (cutoff at 1.5x baud rate)
+      filter_cutoff = [baud_rate * 1.5, (sample_rate / 2.0) - 1].min
+      filter = DSP::Filter.lowpass(
+        cutoff: filter_cutoff,
+        sample_rate: sample_rate,
+        taps: 63
+      )
+      complex_freq = freq.map { |f| Complex(f, 0) }
+      smoothed = filter.apply(complex_freq).map(&:real)
+
+      # Step 3: Decimate to ~4x baud rate for bit decisions
+      target_rate = (baud_rate * 4).to_i
+      target_rate = [target_rate, sample_rate].min
+
+      if sample_rate > target_rate && target_rate.positive?
+        decimated = DSP.resample(
+          smoothed.map { |s| Complex(s, 0) },
+          from_rate: sample_rate,
+          to_rate: target_rate
+        ).map(&:real)
+        effective_rate = target_rate
+      else
+        decimated = smoothed
+        effective_rate = sample_rate
+      end
+
+      return [] if decimated.empty?
+
+      # Step 4: Threshold at midpoint to get raw bits
+      threshold = decimated.sum / decimated.length.to_f
+      raw_bits = decimated.map { |s| s > threshold ? 1 : 0 }
+      raw_bits = raw_bits.map { |b| 1 - b } if invert
+
+      # Step 5: Sample at symbol centers
+      samples_per_symbol = effective_rate.to_f / baud_rate
+      return raw_bits if samples_per_symbol < 1
+
+      output_bits = []
+      offset = (samples_per_symbol / 2.0).to_i
+      index = offset
+
+      while index < raw_bits.length
+        output_bits << raw_bits[index]
+        index += samples_per_symbol.round
+      end
+
+      output_bits
+    end
+
+    # FSK demodulation returning raw discriminator output
+    #
+    # Returns the smoothed frequency discriminator output without bit slicing.
+    # Useful for visualizing FSK signals, debugging, or implementing custom
+    # clock recovery algorithms.
+    #
+    # @param [Array<Complex>] samples Input IQ samples
+    # @param [Integer] sample_rate Input sample rate in Hz
+    # @param [Numeric] baud_rate Symbol rate in baud (used for filter cutoff)
+    # @return [Array<Float>] Smoothed discriminator output
+    # @example Get raw FSK waveform for plotting
+    #   waveform = RTLSDR::Demod.fsk_raw(samples, sample_rate: 48_000, baud_rate: 1200)
+    def self.fsk_raw(samples, sample_rate:, baud_rate:)
+      return [] if samples.empty? || samples.length < 2
+
+      # FM discriminator
+      freq = phase_diff(samples)
+      return [] if freq.empty?
+
+      # Lowpass filter
+      filter_cutoff = [baud_rate * 1.5, (sample_rate / 2.0) - 1].min
+      filter = DSP::Filter.lowpass(
+        cutoff: filter_cutoff,
+        sample_rate: sample_rate,
+        taps: 63
+      )
+      complex_freq = freq.map { |f| Complex(f, 0) }
+      filter.apply(complex_freq).map(&:real)
+    end
+
     # =========================================================================
     # Private Helpers
     # =========================================================================

data/lib/rtlsdr/version.rb

@@ -12,5 +12,5 @@ module RTLSDR
   #
   # @return [String] Current gem version
   # @since 0.1.0
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rtlsdr
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - joshfng