Xilinx
Block Preview

Introduction

The IIR Chebyshev Type 1 - II Order block implements a second-order Chebyshev Type 1 IIR filter operating in real time on FPGA. The component includes automatic filter coefficient calculation based on filter type (low/high pass), cutoff frequency, and passband ripple.

Chebyshev Type 1 filters have a steeper roll-off than Butterworth filters and feature passband ripple. The filter is named after Pafnuty Chebyshev because its mathematical characteristics are derived from Chebyshev polynomials.

Pin Description

IN Input 16U/17S bit BIT VECTOR
Fixed-point number input. Supports 16-bit unsigned or 17-bit signed input based on the DataTypeIn property.
Default: Must be connected
CLK Input 1 bit BIT
Input signal used as clock. All filter operations are synchronous to this clock.
Default: Default Board Clock
RESET Input 1 bit BIT
Synchronous reset signal. Clears the filter state and all internal accumulators.
Default: Default Board Reset
OUT Output 16U/17S bit BIT VECTOR
Fixed-point number output. Same format as input (16-bit unsigned or 17-bit signed).

Properties

Property window

Type of filter Type

Select between low pass and high pass filter

Filter type selection. Available values: Low Pass, High Pass, default Low Pass.

Default: Low Pass

Options: Low Pass High Pass

Cutoff (KHz) Cutoff

Set the filter pole/zero position according to the selected bandwidth in KHz

Cutoff frequency in kHz. Must be less than half the sampling frequency (Nyquist limit).

Default: 1000

Ripple (dB) Ripple

The maximum ripple allowed below unity gain in the passband. Specified in decibels, as a positive number.

Passband ripple in dB. Higher values allow steeper roll-off but more passband variation. Typical values: 0.5 to 3 dB.

Default: 0.1

Input data type DataTypeIn

Select input data type

Input data format selection. Available values: Unsigned 16 bit, Signed 17 bit, default Unsigned 16 bit.

Default: UINT16

Options: UINT16 INT17

Usage

Chebyshev Type 1 Filter Characteristics

Chebyshev Type 1 filters minimize the error between the idealized and actual filter characteristic over the operating frequency range, achieving this with ripples in the passband:

  • Steeper Roll-off: Sharper transition between passband and stopband than Butterworth
  • Passband Ripple: Controlled ripple in the passband (specified in dB)
  • Monotonic Stopband: No ripple in the stopband
  • Higher Selectivity: Better frequency discrimination for same filter order

Chebyshev Type 1 frequency response

Comparison with Other Filters

Filter Type Passband Stopband Roll-off
Butterworth Flat Flat Moderate
Chebyshev 1 Ripple Flat Steep
Chebyshev 2 Flat Ripple Steep
Elliptic Ripple Ripple Steepest

Scattered Lookahead Implementation

To enable real-time FPGA operation at full clock rate, the filter uses the Scattered Lookahead technique:

IIR block diagram

The standard IIR equation:

$$ y[n] = b_0 x[n] + b_1 x[n-1] + b_2 x[n-2] - a_1 y[n-1] - a_2 y[n-2] $$

Is transformed using scattered lookahead to:

Scattered lookahead structure

$$ y[j] = \sum_{k=0}^{6} b’_k x[j-k] - a’_3 y[j-3] - a’_6 y[j-6] $$

Reference: A universal look-ahead algorithm for pipelining IIR filters

Coefficient Calculation

SciCompiler automatically calculates the filter coefficients. The following Python code provides a reference implementation:

python 
  import numpy as np
from scipy import signal

def scattered_lookahead_transform(a):
    A = np.array([[a[0], 0,    0,    0,      0,   ],
                  [a[1], a[0], 0,    0,      0,   ],
                  [a[2], a[1], a[0], 0,      0,   ],
                  [0,    0,    a[2], a[1], a[0],  ],
                  [0,    0,    0,    a[2], a[1],  ]])
    A_inv = np.linalg.inv(A)
    D = A_inv * [1, 0, 0, 0, 0]
    D1 = D[:,0]
    D = D[:,0].reshape(-1, 1)

    R = np.array([[ 0,   a[2], a[1],  a[0],  0,  ],
                  [0,   0,    0,    0,     a[2]]])

    Qw = np.dot(R, D)

    an = [1, Qw[0][0], Qw[1][0]]
    bn = D1
    return bn, an

N = 2               # Order of the filter
fs = 250*1e6        # Sampling frequency
fc = 5*1e6          # Corner frequency
rp = 1              # Passband ripple in dB
Wn = fc/(fs/2)

b_z, a_z = signal.cheby1(N, rp, Wn, btype='low')

print("original", b_z, a_z)
bn, an = scattered_lookahead_transform(a_z)

bq = np.convolve(bn, b_z)
aq = an

print("scattered", bq, aq)

Typical Applications

  • Applications requiring sharper frequency cutoff than Butterworth
  • Band-limited signal processing
  • Where passband ripple is acceptable for better selectivity

Resources & Timing

  • Latency: 8 clock cycles