Sample Rate Change

From GNU Radio
Jump to navigation Jump to search
Beginner Tutorials

Introducing GNU Radio

  1. What is GNU Radio?
  2. Installing GNU Radio
  3. Your First Flowgraph

Flowgraph Fundamentals

  1. Python Variables in GRC
  2. Variables in Flowgraphs
  3. Runtime Updating Variables
  4. Signal Data Types
  5. Converting Data Types
  6. Packing Bits
  7. Streams and Vectors
  8. Hier Blocks and Parameters

Creating and Modifying Python Blocks

  1. Creating Your First Block
  2. Python Block With Vectors
  3. Python Block Message Passing
  4. Python Block Tags

DSP Blocks

  1. Low Pass Filter Example
  2. Designing Filter Taps
  3. Sample Rate Change

This tutorial describes how to implement sample rate change within GNU Radio.

The previous tutorial, Designing Filter Taps, demonstrates how to design filter taps and use them in signal processing blocks. Please complete the Designing Filter Taps tutorial before completing this one.


Interpolation is the process of increasing the sampling rate and thus the available bandwidth. This example demonstrates how to increase the sampling rate using the Interpolating FIR Filter block.

Start by adding the following blocks to the flowgraph and connect them:

  1. Two Variable blocks
  2. Low-Pass Filter Taps
  3. QT GUI Range
  4. Signal Source
  5. Interpolating FIR Filter
  6. Throttle
  7. QT Frequency GUI Sink


Edit the first of the two new variable blocks:

  • Id: interpolation_rate
  • Value: 4

Edit the second of the two new variable blocks:

  • Id: samp_rate_interpolated
  • Value: samp_rate*interpolation_rate

Edit the properties of the Low-Pass Filter Taps block:

  • Id: lowPassTaps
  • Sample Rate (Hz): samp_rate_interpolated
  • Cutoff Freq (Hz): samp_rate_interpolated/(interpolation_rate*2)
  • Transition Width (Hz): samp_rate_interpolated/(interpolation_rate*4)


Edit the properties of the QT GUI Range block:

  • Id: frequency
  • Default Value: 0
  • Start: -samp_rate/2
  • Stop: samp_rate/2

Edit the property of the Signal Source:

  • Frequency: frequency

Edit the properties of the Interpolating FIR Filter block:

  • Interpolation: interpolation_rate
  • Taps: lowPassTaps


The Interpolating FIR Filter increases the sampling rate from 32 kHz to 128 kHz, a factor of 4 due to the interpolation_rate variable. Make a note of this by editing the Comment field under the Advanced tab:


The comment is then displayed as a visual reminder in GRC:


Edit the Throttle property:

  • Sample Rate: samp_rate_interpolated

Edit the QT GUI Frequency Sink property:

  • Bandwidth (Hz): samp_rate_interpolated

The flowgraph looks like the following:


Running the flowgraph shows the following QT GUI Frequency Sink:


The four peaks come from the interpolation operation. Scroll-wheel-click on the window and enable Max Hold:


Drag the frequency slider to show how the four peaks change in frequency, creating an outline of the frequency response of the Interpolating FIR Filter block. The interpolation has increased the sampling rate by a factor of 4, with the low-pass filter taps attenuating the spectral images to minimize distortion.



Where interpolation increases the sample rate, decimation decreases the sample rate and available bandwidth. Starting with the flowgraph from the previous Interpolation example, rename the interpolation_rate variable to decimation_rate. The flowgraph has some errors:


Change the samp_rate_interpolated variable:

  • Id: samp_rate_decimated
  • Value: samp_rate*decimation_rate

Change the Low-Pass Filter Taps block properties:

  • Sample Rate (Hz): samp_rate
  • Cutoff Frequency (Hz): samp_rate/(decimation_rate*2)
  • Transition Width (Hz): samp_rate/(decimation_rate*4)

Replace the Interpolating FIR Filter block with the Decimating FIR Filter block. Update the properties:

  • Decimation: decimation_rate
  • Taps: lowPassTaps

Update the properties for the Throttle block:

  • Sample Rate: samp_rate_decimated

Update the properties for the QT GUI Frequency Sink block:

  • Bandwidth (Hz): samp_rate_decimated

The flowgraph looks like the following:


Run the flowgraph and enable Max Hold. Sweeping the frequency slider across positive frequencies shows the spectral shape of the Decimating FIR Filter:


Note that the bandwidth has been reduced by a factor of 1/4 due to the Decimating FIR Filter block.

Rational Rate Resampling[edit]

The Interpolating FIR Filter and Decimating FIR Filter both change the sample rate by integer values. Situations can arise in which the sample rate needs to be changed by a fractional number such as 2/3. One way to perform a fractional resample is to apply the interpolation by 2 followed by the decimation by 3. A better way is to use the Rational Resampler block.

Starting with the flowgraph from the Decimation example, replace the Decimating FIR Filter with the Rational Resampler.

Add a variable block for the interpolation rate:

  • Id: interpolation_rate
  • Value: 2

Change the value for the decimation_rate variable:

  • Value: 3

Change the properties for the samp_rate_decimated variable:

  • Id: samp_rate_resampled
  • Value: samp_rate*interpolation_rate/decimation_rate

The cutoff-frequency needs to be the minimum between samp_rate/(interpolation_rate*2) and samp_rate/(decimation_rate*2). Since decimation_rate > interpolation_rate, the Low-Pass Filter Taps block already has correct sample rate, cutoff-frequency and transition bandwidth and therefore does not need to be modified.

Change the Sample Rate property for Throttle:

  • Sample Rate: samp_rate_resampled

Change the Bandwidth property for QT GUI Frequency Sink:

  • Bandwidth (Hz): samp_rate_resampled

Update the properties for the Rational Resampler block:

  • Interpolation: interpolation_rate
  • Decimation: decimation_rate
  • Taps: lowPassTaps

The flowgraph looks like the following:


Run the flowgraph and select the Max Hold option. Sweeping the frequency slider over the positive frequencies shows the resampled spectrum:


Note that the bandwidth in this case has been reduced by a factor of 2/3 due to the Rational Resampler block.