# Sample Rate Change

Beginner Tutorials
Introducing GNU Radio Flowgraph Fundamentals - Python Variables in GRC
- Variables in Flowgraphs
- Runtime Updating Variables
- Signal Data Types
- Converting Data Types
- Packing Bits
- Streams and Vectors
- Hier Blocks and Parameters
Creating and Modifying Python Blocks DSP Blocks |

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[edit]

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:

- Two
*Variable*blocks *Low-Pass Filter Taps**QT GUI Range**Signal Source**Interpolating FIR Filter**Throttle**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.

## Decimation[edit]

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.