replaced tabs, added sample_rate, fixed average=True bug

git-svn-id: http://gnuradio.org/svn/gnuradio/trunk@9132 221aa14e-8319-0410-a670-987f0aec2ac5

2 files changed, 116 insertions, 110 deletions

diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/logpwrfft.py b/gnuradio-core/src/python/gnuradio/blks2impl/logpwrfft.py
index 195aefa19..5f074b197 100644
--- a/gnuradio-core/src/python/gnuradio/blks2impl/logpwrfft.py
+++ b/gnuradio-core/src/python/gnuradio/blks2impl/logpwrfft.py
@@ -27,47 +27,48 @@ class _logpwrfft_base(gr.hier_block2):
     """!
     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 @@ class _logpwrfft_base(gr.hier_block2):
         @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
-	
-    def avg_alpha(self):
-	"""!
-	Return averaging filter constant.
-	"""
-	return self._avg_alpha
+        """!
+        Return whether or not averaging is being performed.
+        """
+        return self._average
 
+    def avg_alpha(self):
+        """!
+        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, )
 
diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/stream_to_vector_decimator.py b/gnuradio-core/src/python/gnuradio/blks2impl/stream_to_vector_decimator.py
index 631657b99..ff3a6b955 100644
--- a/gnuradio-core/src/python/gnuradio/blks2impl/stream_to_vector_decimator.py
+++ b/gnuradio-core/src/python/gnuradio/blks2impl/stream_to_vector_decimator.py
@@ -27,54 +27,54 @@ class stream_to_vector_decimator(gr.hier_block2):
     """
 
     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