[Commit-gnuradio] r9132 - gnuradio/trunk/gnuradio-core/src/python/gnuradio/blks2impl

[jblum]

Author: jblum
Date: 2008-08-01 13:27:53 -0600 (Fri, 01 Aug 2008)
New Revision: 9132

Modified:
   gnuradio/trunk/gnuradio-core/src/python/gnuradio/blks2impl/logpwrfft.py
   
gnuradio/trunk/gnuradio-core/src/python/gnuradio/blks2impl/stream_to_vector_decimator.py
Log:
replaced tabs, added sample_rate, fixed average=True bug

Modified: 
gnuradio/trunk/gnuradio-core/src/python/gnuradio/blks2impl/logpwrfft.py
===================================================================
--- gnuradio/trunk/gnuradio-core/src/python/gnuradio/blks2impl/logpwrfft.py     
2008-08-01 18:55:43 UTC (rev 9131)
+++ gnuradio/trunk/gnuradio-core/src/python/gnuradio/blks2impl/logpwrfft.py     
2008-08-01 19:27:53 UTC (rev 9132)
@@ -27,47 +27,48 @@
     """!
     Create a log10(abs(fft)) stream chain, with real or complex input.
     """
-       
+
     def __init__(self, sample_rate, fft_size, ref_scale, frame_rate, 
avg_alpha, average):
-       """!
-       Create an log10(abs(fft)) stream chain.
-       Provide access to the setting the filter and sample rate.
-       @param sample_rate      Incoming stream sample rate
-       @param fft_size         Number of FFT bins
-       @param ref_scale        Sets 0 dB value input amplitude
-       @param frame_rate       Output frame rate
-       @param avg_alpha        FFT averaging (over time) constant [0.0-1.0]
-       @param average          Whether to average [True, False]
-       """
-       gr.hier_block2.__init__(self, self._name, 
-                               gr.io_signature(1, 1, self._item_size),         
 # Input signature
-                               gr.io_signature(1, 1, 
gr.sizeof_float*fft_size)) # Output signature
+        """!
+        Create an log10(abs(fft)) stream chain.
+        Provide access to the setting the filter and sample rate.
+        @param sample_rate        Incoming stream sample rate
+        @param fft_size                Number of FFT bins
+        @param ref_scale        Sets 0 dB value input amplitude
+        @param frame_rate        Output frame rate
+        @param avg_alpha        FFT averaging (over time) constant [0.0-1.0]
+        @param average                Whether to average [True, False]
+        """
+        gr.hier_block2.__init__(self, self._name,
+                                gr.io_signature(1, 1, self._item_size),        
  # Input signature
+                                gr.io_signature(1, 1, 
gr.sizeof_float*fft_size)) # Output signature
 
-       self._sd = stream_to_vector_decimator(item_size=self._item_size,
-                                             sample_rate=sample_rate,
-                                             vec_rate=frame_rate,
-                                             vec_len=fft_size)
-               
-       fft_window = window.blackmanharris(fft_size)
-       fft = self._fft_block[0](fft_size, True, fft_window)
-       window_power = sum(map(lambda x: x*x, fft_window))
+        self._sd = stream_to_vector_decimator(item_size=self._item_size,
+                                              sample_rate=sample_rate,
+                                              vec_rate=frame_rate,
+                                              vec_len=fft_size)
 
-       c2mag = gr.complex_to_mag(fft_size)
-       self._avg = gr.single_pole_iir_filter_ff(1.0, fft_size)
-       self._log = gr.nlog10_ff(20, fft_size,
-                                -10*math.log10(fft_size)              # Adjust 
for number of bins
-                                -10*math.log10(window_power/fft_size) # Adjust 
for windowing loss
-                                -20*math.log10(ref_scale/2))          # Adjust 
for reference scale
-       self.connect(self, self._sd, fft, c2mag, self._avg, self._log, self)
-       self.set_average(average)
-       self.set_avg_alpha(avg_alpha)
+        fft_window = window.blackmanharris(fft_size)
+        fft = self._fft_block[0](fft_size, True, fft_window)
+        window_power = sum(map(lambda x: x*x, fft_window))
 
+        c2mag = gr.complex_to_mag(fft_size)
+        self._avg = gr.single_pole_iir_filter_ff(1.0, fft_size)
+        self._log = gr.nlog10_ff(20, fft_size,
+                                 -10*math.log10(fft_size)              # 
Adjust for number of bins
+                                 -10*math.log10(window_power/fft_size) # 
Adjust for windowing loss
+                                 -20*math.log10(ref_scale/2))          # 
Adjust for reference scale
+        self.connect(self, self._sd, fft, c2mag, self._avg, self._log, self)
+        self.set_average(False)
+        self.set_avg_alpha(avg_alpha)
+        self.set_average(average)
+
     def set_sample_rate(self, sample_rate):
-       """!
-       Set the new sampling rate
-       @param sample_rate the new rate
-       """
-       self._sd.set_sample_rate(sample_rate)
+        """!
+        Set the new sampling rate
+        @param sample_rate the new rate
+        """
+        self._sd.set_sample_rate(sample_rate)
 
     def set_average(self, average):
         """!
@@ -75,45 +76,50 @@
         @param average true to set averaging on
         """
         self._average = average
-        if self._average: 
-           self._avg.set_taps(self._avg_alpha)
-       else: 
-           self._avg.set_taps(1.0)
+        if self._average:
+            self._avg.set_taps(self._avg_alpha)
+        else:
+            self._avg.set_taps(1.0)
 
     def set_avg_alpha(self, avg_alpha):
-       """!
-       Set the average alpha and set the taps if average was on.
-       @param avg_alpha the new iir filter tap
-       """
-       self._avg_alpha = avg_alpha
-       self.set_average(self._average)
+        """!
+        Set the average alpha and set the taps if average was on.
+        @param avg_alpha the new iir filter tap
+        """
+        self._avg_alpha = avg_alpha
+        self.set_average(self._average)
 
+    def sample_rate(self):
+        """!
+        Return the current sample rate.
+        """
+        return self._sd.sample_rate()
+
     def average(self):
-       """!
-       Return whether or not averaging is being performed.
-       """
-       return self._average
-       
+        """!
+        Return whether or not averaging is being performed.
+        """
+        return self._average
+
     def avg_alpha(self):
-       """!
-       Return averaging filter constant.
-       """
-       return self._avg_alpha
+        """!
+        Return averaging filter constant.
+        """
+        return self._avg_alpha
 
-
 class logpwrfft_f(_logpwrfft_base):
-       """!
-       Create an fft block chain, with real input.
-       """
-       _name = "logpwrfft_f"
-       _item_size = gr.sizeof_float
-       _fft_block = (gr.fft_vfc, )
+        """!
+        Create an fft block chain, with real input.
+        """
+        _name = "logpwrfft_f"
+        _item_size = gr.sizeof_float
+        _fft_block = (gr.fft_vfc, )
 
 class logpwrfft_c(_logpwrfft_base):
-       """!
-       Create an fft block chain, with complex input.
-       """
-       _name = "logpwrfft_c"
-       _item_size = gr.sizeof_gr_complex
-       _fft_block = (gr.fft_vcc, )
+        """!
+        Create an fft block chain, with complex input.
+        """
+        _name = "logpwrfft_c"
+        _item_size = gr.sizeof_gr_complex
+        _fft_block = (gr.fft_vcc, )
 

Modified: 
gnuradio/trunk/gnuradio-core/src/python/gnuradio/blks2impl/stream_to_vector_decimator.py
===================================================================
--- 
gnuradio/trunk/gnuradio-core/src/python/gnuradio/blks2impl/stream_to_vector_decimator.py
    2008-08-01 18:55:43 UTC (rev 9131)
+++ 
gnuradio/trunk/gnuradio-core/src/python/gnuradio/blks2impl/stream_to_vector_decimator.py
    2008-08-01 19:27:53 UTC (rev 9132)
@@ -27,54 +27,54 @@
     """
 
     def __init__(self, item_size, sample_rate, vec_rate, vec_len):
-       """!
-       Create the block chain.
-       @param item_size the number of bytes per sample
-       @param sample_rate the rate of incoming samples
-       @param vec_rate the rate of outgoing vectors (same units as sample_rate)
-       @param vec_len the length of the outgoing vectors in items
-       """
-       self._vec_rate = vec_rate
-       self._vec_len = vec_len
-       self._sample_rate = sample_rate
-       
-       gr.hier_block2.__init__(self, "stream_to_vector_decimator",
-                               gr.io_signature(1, 1, item_size),         # 
Input signature
-                               gr.io_signature(1, 1, item_size*vec_len)) # 
Output signature
+        """!
+        Create the block chain.
+        @param item_size the number of bytes per sample
+        @param sample_rate the rate of incoming samples
+        @param vec_rate the rate of outgoing vectors (same units as 
sample_rate)
+        @param vec_len the length of the outgoing vectors in items
+        """
+        self._vec_rate = vec_rate
+        self._vec_len = vec_len
+        self._sample_rate = sample_rate
 
-       s2v = gr.stream_to_vector(item_size, vec_len)
-       self.one_in_n = gr.keep_one_in_n(item_size*vec_len, 1)
-       self._update_decimator()
-       self.connect(self, s2v, self.one_in_n, self)
+        gr.hier_block2.__init__(self, "stream_to_vector_decimator",
+                                gr.io_signature(1, 1, item_size),         # 
Input signature
+                                gr.io_signature(1, 1, item_size*vec_len)) # 
Output signature
 
+        s2v = gr.stream_to_vector(item_size, vec_len)
+        self.one_in_n = gr.keep_one_in_n(item_size*vec_len, 1)
+        self._update_decimator()
+        self.connect(self, s2v, self.one_in_n, self)
+
     def set_sample_rate(self, sample_rate):
-       """!
-       Set the new sampling rate and update the decimator.
-       @param sample_rate the new rate
-       """
-       self._sample_rate = sample_rate
-       self._update_decimator()
+        """!
+        Set the new sampling rate and update the decimator.
+        @param sample_rate the new rate
+        """
+        self._sample_rate = sample_rate
+        self._update_decimator()
 
     def set_vec_rate(self, vec_rate):
-       """!
-       Set the new vector rate and update the decimator.
-       @param vec_rate the new rate
-       """
-       self._vec_rate = vec_rate
-       self._update_decimator()
-       
+        """!
+        Set the new vector rate and update the decimator.
+        @param vec_rate the new rate
+        """
+        self._vec_rate = vec_rate
+        self._update_decimator()
+
     def _update_decimator(self):
-       self._decim = max(1, 
int(self._sample_rate/self._vec_len/self._vec_rate))
-       self.one_in_n.set_n(self._decim)
+        self._decim = max(1, 
int(self._sample_rate/self._vec_len/self._vec_rate))
+        self.one_in_n.set_n(self._decim)
 
     def sample_rate(self):
-       """!
-       Returns configured sample rate.
-       """
-       return self._sample_rate
-       
+        """!
+        Returns configured sample rate.
+        """
+        return self._sample_rate
+
     def frame_rate(self):
-       """!
-       Returns actual frame rate
-       """
-       return self._sample_rate/self._vec_len/self._decim
+        """!
+        Returns actual frame rate
+        """
+        return self._sample_rate/self._vec_len/self._decim