radio 0.0.2 → 0.0.3

data/lib/radio/gif.rb

@@ -20,64 +20,62 @@
 class Radio
   class Gif
   
-    # This is an optimized GIF generator for waterfalls. 
+    # This is a very fast GIF generator for waterfalls.
     # It requires 128 RGB colors, the first is unused and
     # reserved for transparency if we ever need it.
-    def self.waterfall colors, data
-
+    # data is expected to be an NArray
+    def self.waterfall colors, data, min=nil, max=nil
+      width = data[true,0].size
+      height = data[0,true].size
       gif = [
         'GIF87a', # Start Header
-        data[0].size, # width
-        data.size, # height
+        width,
+        height,
         0xF6, # 128 24-bit colors
         0x00, # background color index
         0x00 # aspect ratio
       ].pack 'a6vvCCC'
-
       gif += colors.flatten.pack 'C*'
-
       gif += [
         0x2C, # Start Image Block
         0x0000, # Left position
         0x0000, # Top position
-        data[0].size, # width
-        data.size, # height
+        width,
+        height,
         0x00, # No color table, not interlaced
         0x07 # LZW code size
       ].pack('CvvvvCC')
-
-      data.each_with_index do |vals, row|
-        col = 0
-        min = vals.min
-        range = [1e-99, vals.max - min].max
-        while col < vals.size
-          # Uncompressed GIF trickery avoids bit packing too
-          # 126 byte chunks with reset keeps LZW in 8 bit codes
-          col_end = [col+126,vals.size].min
-          slice = vals.slice(col...col_end).to_a
-          # This 126 because palette is 1..127
-          slice = slice.collect { |x| (x - min) / range * 126 + 1 }
-          slice = slice.pack 'C*'
-          newstuff = [
-            slice.size+1,
-            slice,
-            0x80 # LZW reset
-          ].pack('Ca*C')
-          gif += newstuff
-          col += 126
+      data = data.reshape(data.size)
+      min ||= data.min
+      max ||= data.max
+      range = [1e-99, max - min].max
+      data -= min # will dup
+      data.div!(range).mul!(126).add!(1)
+      # add in a frame+reset every 126 plus the 4 byte end block
+      predict = gif.size + (data.size+125) / 126 * 2 + data.size + 4
+      out = NArray.byte predict
+      out[0...gif.size] = NArray.to_na gif, NArray::BYTE, gif.size
+      i = 0
+      pos = gif.size
+      while i < data.size
+        qty = [126,data.size-i].min
+        out[pos] = qty+1
+        pos+=1
+        if qty == 1
+          out[pos] = data[i]
+        else
+          out[pos...pos+qty] = data[i...i+qty]
         end
-
+        pos+=qty
+        out[pos] = 0x80 # LZW reset
+        pos+=1
+        i += qty
       end
-
-      gif += [
-        0x01, # end image blocks
-        0x81, # final image block: LZW end
-        0x00, # end image blocks
-        0x3B # end gif
-      ].pack('C*')
-
-      return gif
-  
+      out[pos] = 0x01, # end image blocks
+      out[pos+1] = 0x81, # final image block: LZW end
+      out[pos+2] = 0x00, # end image blocks
+      out[pos+3] = 0x3B # end gif
+      out.to_s
     end
 
   end

data/lib/radio/psk31/rx.rb

@@ -18,10 +18,18 @@ class Radio
   class PSK31
     
     class Rx
+      
+      include Utils
+  
+      # 16 Hz bw LP filter for data recovery
+      FIR_BIT = FirPM.new numtaps: 65, type: :bandpass,
+        bands: [0.0,0.03125,0.0625,0.5], desired: [1,1,0,0], weights: [1,286]
 
       def initialize frequency
-        phase_inc = PI2 * frequency / 8000
-        @dec_filter = Filter.new mix:phase_inc, decimate:16, fir:FIR_DEC16
+        mix = frequency.to_f / 8000
+        fir_500hz = firpm numtaps: 35, type: :bandpass,
+          bands: [0,0.0125,0.125,0.5], desired: [1,1,0,0], weights: [1,10]
+        @dec_filter = Filter.new mix:mix, decimate:16, fir:fir_500hz
         @bit_filter = Filter.new fir:FIR_BIT
         @bit_detect = BitDetect.new
         @decoder = Decoder.new
@@ -29,11 +37,13 @@ class Radio
       
       def call data
         decoded = ''
-        @dec_filter.call data do |iq|
-          @bit_filter.call iq do |iq|
-            @bit_detect.call iq do |iq|
-              @decoder.call iq do |symbol|
-                decoded += symbol
+        @dec_filter.call data do |data|
+          @bit_filter.call data do |data|
+            data.each do |iq|
+              @bit_detect.call iq do |iq|
+                @decoder.call iq do |symbol|
+                  decoded += symbol
+                end
               end
             end
           end

data/lib/radio/rig.rb

@@ -17,30 +17,52 @@ class Radio
 
   class Rig
     
+    include Utils
     include Spectrum
     include Rx
     include LO
+    include SSB
   
     def initialize
       @semaphore = Mutex.new
+      @listeners = {}
+      @listeners_mutex = Mutex.new
       super
     end
     
+    def register queue
+      @listeners_mutex.synchronize do
+        @listeners[queue] = true
+      end
+    end
+
+    def deregister queue
+      @listeners_mutex.synchronize do
+        @listeners.delete queue
+      end
+    end
+    
     def rate
       @semaphore.synchronize do
         return @rx.rate if @rx
-        return @tx.rate if @tx
         return 0
       end
     end
     
     def iq?
       @semaphore.synchronize do
-        return @rx.channels == 2 if @rx
-        return @tx.channels == 2 if @tx
+        return @rx.input_channels == 2 if @rx
         return false
       end
     end
+    
+    private
+    
+    def distribute_to_listeners data
+      @listeners_mutex.synchronize do
+        @listeners.each {|k,v| k << data }
+      end
+    end
 
   end
 end

data/lib/radio/rig/rx.rb

@@ -18,14 +18,14 @@ class Radio
   class Rig
     
     module Rx
-  
+      
       def initialize
         @rx = @rx_thread = nil
         super
       end
       
       def rx= input
-        old_rx_thread = new_thread = false
+        old_rx_thread = false
         @semaphore.synchronize do
           if @rx
             @rx.stop
@@ -46,10 +46,15 @@ class Radio
       # We want to work with powers of two but sample rates
       # are multiples of 8000. Let's use a lag of 32ms or 31.25 baud.
       def rx_thread
-        qty_samples = @rx.rate / 125 * 4
-        loop do
-          samples = @rx.call qty_samples
-          spectrum_collect samples
+        begin
+          qty_samples = @rx.rate / 125 * 4
+          loop do
+            distribute_to_listeners @rx.in qty_samples
+          end
+        rescue Exception => e
+          p "ERROR #{e.message}: #{e.backtrace.first}" #TODO logger
+          # This will be picked up by next call to rx=
+          raise e
         end
       end
     

data/lib/radio/rig/spectrum.rb

@@ -19,7 +19,10 @@ class Radio
   
       def initialize
         @spectrum_buf = {}
+        @spectrum_semaphore = Mutex.new
         @spectrum_pending = Hash.new {|h,k|h[k]=[]}
+        register @spectrum_queue = Queue.new
+        Thread.start &method(:spectrum_collector)
         super
       end
 
@@ -31,7 +34,7 @@ class Radio
       # Results are not queued; missed processing is skipped.
       # This is meant to be an ideal interface for Web UI work, not signal analysis.
       def spectrum size, frequency=1.0, keep_alive=2.0
-        @semaphore.synchronize do
+        @spectrum_semaphore.synchronize do
           @spectrum_pending[[size, frequency, keep_alive]] << Thread.current
         end
         sleep
@@ -40,53 +43,61 @@ class Radio
   
       private
     
-      def spectrum_collect samples
-        time_now = Time.now
-        @semaphore.synchronize do
-          # Ensure buffers for all requested setups are in place
-          @spectrum_pending.keys.each do |size, frequency, keep_alive|
-            @spectrum_buf[[size, frequency, keep_alive]] ||= [nil,[],nil]
-            @spectrum_buf[[size, frequency, keep_alive]][0] = time_now
-          end
-          # Stop running anything that's not being used anymore
-          @spectrum_buf.delete_if { |k,v| v[0] < time_now - k[2] }
-          # Handle the data for each active buffer
-          @spectrum_buf.each do |k,v|
-            time, data, result = v
-            size, frequency, keep_alive = k
-            collect_size = size * ((Float === samples[0]) ? 2 : 1)
-            data.push samples
-            buf_size = data.reduce(0){|a,b|a+b.size}
-            size_freq = collect_size*frequency
-            # Wait until we have enough data and the time is right
-            if buf_size > collect_size and buf_size > size_freq
-              # Discard any extra data we won't use (frequency>1)
-              while buf_size - data.first.size > collect_size
-                buf_size -= data.shift.size
+      def spectrum_collector
+        begin
+          loop do
+            samples = @spectrum_queue.pop
+            time_now = Time.now
+            @spectrum_semaphore.synchronize do
+              # Ensure buffers for all requested setups are in place
+              @spectrum_pending.keys.each do |size, frequency, keep_alive|
+                @spectrum_buf[[size, frequency, keep_alive]] ||= [nil,[],nil]
+                @spectrum_buf[[size, frequency, keep_alive]][0] = time_now
               end
-              pending_key = [size, frequency, keep_alive]
-              if @spectrum_pending.has_key? pending_key
-                spectrum_data = NArray.to_na data
-                spectrum_data.reshape! spectrum_data.total
-                spectrum_out = FFTW3.fft(spectrum_data[-collect_size..-1]) 
-                if spectrum_out.size == size
-                  result = NArray.sfloat size
-                  result[0...size/2] = spectrum_out[size/2..-1].div!(size)
-                  result[size/2..-1] = spectrum_out[0...size/2].div!(size)
-                  v[2] = result.abs
-                else
-                  v[2] = spectrum_out[0...size].div!(size).abs
+              # Stop running anything that's not being used anymore
+              @spectrum_buf.delete_if { |k,v| v[0] < time_now - k[2] }
+              # Handle the data for each active buffer
+              @spectrum_buf.each do |k,v|
+                time, data, result = v
+                size, frequency, keep_alive = k
+                collect_size = size * ((Float === samples[0]) ? 2 : 1)
+                data.push samples
+                buf_size = data.reduce(0){|a,b|a+b.size}
+                size_freq = collect_size*frequency
+                # Wait until we have enough data and the time is right
+                if buf_size > collect_size and buf_size > size_freq
+                  # Discard any extra data we won't use (frequency>1)
+                  while buf_size - data.first.size > collect_size
+                    buf_size -= data.shift.size
+                  end
+                  pending_key = [size, frequency, keep_alive]
+                  if @spectrum_pending.has_key? pending_key
+                    spectrum_data = NArray.to_na data
+                    spectrum_data.reshape! spectrum_data.total
+                    spectrum_out = FFTW3.fft(spectrum_data[-collect_size..-1]) 
+                    if spectrum_out.size == size
+                      result = NArray.sfloat size
+                      result[0...size/2] = spectrum_out[size/2..-1].div!(size)
+                      result[size/2..-1] = spectrum_out[0...size/2].div!(size)
+                      v[2] = result.abs
+                    else
+                      v[2] = spectrum_out[0...size].div!(size).abs
+                    end
+                    @spectrum_pending[pending_key].each(&:wakeup)
+                    @spectrum_pending.delete pending_key
+                  end
+                  # Discard enough old buffers to accommodate the frequency
+                  trim_size = [0, collect_size - size*frequency].max
+                  while buf_size > trim_size
+                    buf_size -= data.shift.size
+                  end
                 end
-                @spectrum_pending[pending_key].each(&:wakeup)
-                @spectrum_pending.delete pending_key
-              end
-              # Discard enough old buffers to accommodate the frequency
-              trim_size = [0, collect_size - size*frequency].max
-              while buf_size > trim_size
-                buf_size -= data.shift.size
               end
             end
           end
+        rescue Exception => e
+          p "ERROR #{e.message}: #{e.backtrace.first}" #TODO logger
+          raise e
         end
       end
     

data/lib/radio/rig/ssb.rb

@@ -0,0 +1,190 @@
+# Copyright 2012 The ham21/radio Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class Radio
+  
+  class Rig
+
+    module SSB
+      
+      def initialize
+        @ssb_semaphore = Mutex.new
+        super
+      end
+      
+      def af= output
+        if output and !iq?
+          raise 'requires i/q signal'
+        end
+        old_af_thread = false
+        @ssb_semaphore.synchronize do
+          deregister @af_queue if @af_queue
+          @af_queue = nil
+          old_rate = 0
+          if @af
+            @af.stop
+            old_af_thread = @af_thread
+            old_af_thread.kill if old_af_thread
+          end
+          if @af = output
+            @bfo_filter = bfo_mixer
+            @af_filter = af_generate_filter
+            @agc = Filter.new :agc => true
+            @iq = Filter.new :iq => true
+            @mix = mixmix
+          
+            #TODO need a nicer pattern to force JIT compile
+            @bfo_filter.call(NArray.scomplex(1)) {}
+            @af_filter.call(NArray.sfloat(1)) {}
+            @agc.call(NArray.sfloat(1)) {}
+            @iq.call(NArray.scomplex(1)) {}
+          
+            register @af_queue = Queue.new
+            @af_thread = Thread.new &method(:af_thread)
+          end
+        end
+        old_af_thread.join if old_af_thread
+      end
+      
+      def tune= freq
+        @ssb_semaphore.synchronize do
+          @freq = freq
+          set_mixers
+        end
+      end
+      
+      def set_lsb
+        @ssb_semaphore.synchronize do
+          if @bfo_filter
+            @ssb_mode = :lsb
+            @bfo_filter.decimation_fir = @lsb_coef 
+            set_mixers
+          end
+        end
+      end
+
+      def set_usb
+        @ssb_semaphore.synchronize do
+          if @bfo_filter
+            @ssb_mode = :usb
+            @bfo_filter.decimation_fir = @usb_coef
+            set_mixers
+          end
+        end
+      end
+      
+      private
+      
+      def set_mixers
+        return unless @af and @bfo_filter
+        freq = @freq.to_f 
+        if @ssb_mode == :usb
+          @bfo_filter.decimation_mix = (freq-1300) / rate
+          @mix.mix = +1300.0 / 6000
+        else
+          @bfo_filter.decimation_mix = (freq+1300) / rate
+          @mix.mix = -1300.0 / 6000
+        end
+      end
+      
+      def af_thread
+        begin
+          loop do
+            in_data = @af_queue.pop
+            @ssb_semaphore.synchronize do
+              if @af_filter and @af
+                @bfo_filter.call(in_data) do |iq|
+                  
+                  @mix.call!(iq) do |iq|
+                  @iq.call!(iq) do |iq|
+                  
+                    @agc.call(iq.real + iq.imag) do |pcm|
+                      @af_filter.call(pcm) do |data| 
+                        @af.out data
+                      end
+                    end
+                  end
+                  end
+                end
+              end
+            end
+          end
+        rescue Exception => e
+          p "ERROR #{e.message}: #{e.backtrace.first}" #TODO logger
+          raise e
+        end
+      end
+      
+      def mixmix
+        rate = 6000
+        bands = []
+        bands[0] = 0.0 / rate
+        bands[1] = 2400.0 / rate
+        bands[2] = 2600.0 / rate
+        bands[3] = 0.5
+        taps = kaiser_estimate passband:0.01, stopband:0.01, transition:bands[2]-bands[1]
+        fir = firpm numtaps: taps, type: :bandpass,
+          bands: bands, desired: [1,1,0,0], weights: [1,1000]
+        Filter.new :mix => (1300.0 / rate), :fir => fir
+      end
+
+      def bfo_mixer
+        rate = self.rate.to_f
+        decimate = rate / 6000
+        unless decimate == decimate.floor
+          raise "unable to filter #{rate} to 6000"
+        end
+        bands = []
+        bands[0] = 0.0 / rate
+        bands[1] = 1200.0 / rate
+        bands[2] = 1500.0 / rate
+        bands[3] = 0.5
+        taps = kaiser_estimate passband:0.1, stopband:0.1, transition:bands[2]-bands[1]
+        p taps
+        taps = 271
+        p taps
+        fir1 = firpm numtaps: taps, type: :bandpass,
+          bands: bands, desired: [1,1,0,0], weights: [1,10000]
+        fir2 = firpm numtaps: taps, type: :hilbert,
+          bands: bands, desired: [1,1,0,0], weights: [1,10000]
+        @usb_coef = NArray.scomplex fir1.size
+        @usb_coef[true] = fir1.to_a
+        @usb_coef.imag = fir2.to_a
+        @lsb_coef = @usb_coef.conj
+        @ssb_mode = :usb
+        Filter.new fir:@usb_coef, decimate:decimate, mix:0
+      end
+      
+      def af_generate_filter
+        return nil unless @af
+        bands = [0,nil,nil,0.5]
+        bands[1] = 2400.0 / @af.rate
+        bands[2] = 3000.0 / @af.rate
+        taps = kaiser_estimate passband:0.01, stopband:0.01, transition:bands[2]-bands[1]
+        fir = firpm numtaps: taps, type: :bandpass,
+          bands: bands, desired: [1,1,0,0], weights: [1,1000]
+        interpolate = @af.rate.to_f / 6000
+        unless interpolate == interpolate.floor
+          raise "unable to filter 6000 to #{@af.rate}"
+        end
+        Filter.new fir:fir, interpolate:interpolate
+      end
+      
+      
+    end
+
+  end
+end
+