updated iir filter

Author: GGChe

IIRFilterDesign.py

@@ -9,6 +9,7 @@
 f1 = 50
 f2 = 200
 
+# Here there are two ve
 
 
 b, a = signal.iirfilter(n, [2*np.pi*f1, 2*np.pi*f2], rs=60,

IIR_Filter_Design.py

@@ -22,7 +22,7 @@ Import
 
 Use the command to import it:
 
-  import iir-filter
+  import iir
 
 Calculate the coefficients
 ==========================
@@ -37,7 +37,7 @@ Instantiate the filter
 
 You can create an instance of the IIR filter by calling it:
 
-    f = iir_filter.IIR_filter(sos)
+    f = iir.IIR_filter(sos)
 
 Filtering Flow
 ====

README.md

@@ -7,105 +7,48 @@
 import matplotlib.pylab as plt
 import numpy as np
 from scipy import signal
+import iir
 
-SAMPLE_RATE = 2000  # Hertz
-DURATION = 5  # Seconds
-NTAPS = 1000
-SAMPLES = DURATION * SAMPLE_RATE
-fs = SAMPLE_RATE
+fs = 2000  # Hertz
 
 def generate_sine_wave(freq, sample_rate, duration, magnitude):
-    x = np.linspace(0, duration, sample_rate * duration, endpoint=False)
+    x = np.linspace(0, duration, fs * duration, endpoint=False)
     frequencies = x * freq
     y = magnitude * np.sin((2 * np.pi) * frequencies)
     return x, y
-
-class IIR2Filter(object):
-    """
-    given a set of coefficients for the IIR filter this class creates an object that keeps the variables needed for the
-    IIR filtering as well as creating the function "filter(x)" with filters the input data.
-    Attributes:
-        @:param coefficients: input coefficients of the IIR filter as an array of 6 elements where the first three
-        coefficients are for the FIR filter part of the IIR filter and the last three coefficients are for the IIR part
-        of the IIR filter.
-    """
-
-    def __init__(self, coefficients):
-        self.myCoefficients = coefficients
-        self.IIRcoeff = self.myCoefficients[3:6]
-        self.FIRcoeff = self.myCoefficients[0:3]
-        self.acc_input = 0
-        self.acc_output = 0
-        self.buffer1 = 0
-        self.buffer2 = 0
-        self.input = 0
-        self.output = 0
-
-    def filter(self, input):
-        """
-        :param input: input value to be processed.
-        :return: processed value.
-        """
-
-        self.input = input
-        self.output = 0
-
-        """
-        IIR Part of the filter:
-            The accumulated input are the values of the IIR coefficients multiplied by the variables of the filter: 
-            the input and the delay lines.
-        """
-        self.acc_input = (self.input + self.buffer1
-                          * -self.IIRcoeff[1] + self.buffer2 * -self.IIRcoeff[2])
-
-        """
-        FIR Part of the filter:     
-            The accumulated output are the values of the FIR coefficients multiplied by the variables of the filter: 
-            the input and the delay lines. 
-        
-        """
-
-        self.acc_output = (self.acc_input * self.FIRcoeff[0]
-                           + self.buffer1 * self.FIRcoeff[1] + self.buffer2
-                           * self.FIRcoeff[2])
-
-        # Shifting the values on the delay line: acc_input->buffer1->buffer2
-        self.buffer2 = self.buffer1
-        self.buffer1 = self.acc_input
-        self.input = self.acc_output
-        self.output = self.acc_output
-        return self.output
 
+# Generate 2 sinusoidal waves with a frequencies of 1 and 50 Hz for test
 f1 = 1
 f2 = 50
 magnitude_1 = 1
 magnitude_2 = 0.5
-x, sine1 = generate_sine_wave(f1, SAMPLE_RATE, DURATION, magnitude_1)
-_, noise = generate_sine_wave(f2, SAMPLE_RATE, DURATION, magnitude_2)
+DURATION = 5  # Seconds
+x, sine1 = generate_sine_wave(f1, fs, DURATION, magnitude_1)
+_, noise = generate_sine_wave(f2, fs, DURATION, magnitude_2)
 mysignal = sine1 + noise
+
 plt.figure(1)
 plt.plot(mysignal)
 
 # ----------- IIR filter -------------- 
-cutoff = [0.5, 45]
 order = 20
 fs =  2000
-for i in range(len(cutoff)):
-    cutoff[i] = cutoff[i]/(fs * 2)
+f1 = 0.5 /(fs * 2)
+f2 = 45 /(fs * 2)
 
 cutoff =[0.000125, 0.01125] 
+
 coeff = signal.butter(order, cutoff, 'bandpass', output='sos')
 
 # If the order of the filter is 1, is one IIR 2nd order filter otherwise, it is a chain of IIR filters.
+SAMPLES = DURATION * fs
 
-myFilter = IIR2Filter(coeff[0])
-
+myFilter = iir.IIR_filter(coeff)
 y = np.zeros(SAMPLES)
 for i in range(SAMPLES):
     y[i] = myFilter.filter(mysignal[i])
 
-# np.savetxt('coefficients.dat', b, fmt='%f', delimiter='')
-
+# Now plot original and filtered signal
 plt.figure(2)
 plt.subplot(211)
 plt.plot(mysignal)
@@ -114,20 +57,19 @@ def filter(self, input):
 plt.plot(y)
 # plt.ylim((-150, 300))
 
+# Calculate the fourier trasnform 
 unfilteredfft = np.fft.fft(mysignal)
 IIRfilteredfft = np.fft.fft(y)
 
-T = 1/SAMPLE_RATE
-
-# 1/T = frequency
-f = np.linspace(0, SAMPLE_RATE, SAMPLES)
+T = 1/fs
+f = np.linspace(0, fs, SAMPLES)
 
 plt.figure(3)
 plt.subplot(211)
-plt.plot(f[:SAMPLES // 2], np.abs(unfilteredfft)[:SAMPLES // 2] * 1 / SAMPLES)  # 1 / N is a normalization factor
-# plt.plot(20.0*np.log10(unfilteredfft))
+plt.plot(f[:SAMPLES // 2], np.abs(unfilteredfft)[:SAMPLES // 2] * 1 / SAMPLES)  
 plt.subplot(212)
-plt.plot(f[:SAMPLES // 2], np.abs(IIRfilteredfft)[:SAMPLES // 2] * 1 / SAMPLES)  # 1 / N is a normalization factor
+plt.plot(f[:SAMPLES // 2], np.abs(IIRfilteredfft)[:SAMPLES // 2] * 1 / SAMPLES) # 1 / N is a normalization factor
+
+np.savetxt('coefficients.dat', b, fmt='%f', delimiter='')
 
-print(coeff)
 plt.show()