RapidSheets

Circuit: To build a low-pass filter, connect a resistor (R) in series with a capacitor (C). The output is taken across the capacitor. The cutoff frequency (f_c) is determined by the formula: f_c = 1 / (2πRC).
Simple Circuit Diagram:

                    R
             +----/\/\/\/\-----+
             |                 |
             |                 C
            Vin               | |  
             |                 |
             +-----------------+
                       Vout
            

This diagram represents the low-pass filter circuit with a resistor (R) and capacitor (C). The input voltage (Vin) is applied to the series combination of R and C, and the output voltage (Vout) is taken across the capacitor.

Quick Reference:

• Cutoff Frequency: f_c = 1 / (2πRC)
• Impedance of Capacitor: Z_C = 1 / (2πfC)
• Impedance of Resistor: Z_R = R
• Transfer Function: H(f) = 1 / (1 + j(f/f_c))
• Phase Shift: θ(f) = -atan(f/f_c)

    import numpy as np
    import matplotlib.pyplot as plt
    
    # Parameters
    f_c = 1590  # Cutoff frequency in Hz for R=10kΩ and C=10nF
    R = 10000   # Resistance in ohms
    C = 10e-9   # Capacitance in farads
    
    # Frequency response
    frequencies = np.logspace(1, 6, 500)
    H = 1 / (1 + 1j * frequencies / (2 * np.pi * f_c))
    
    plt.figure()
    plt.semilogx(frequencies, 20 * np.log10(abs(H)))
    plt.title('Low-Pass Filter Frequency Response')
    plt.xlabel('Frequency (Hz)')
    plt.ylabel('Magnitude (dB)')
    plt.grid(which='both', axis='both')
    plt.show()
            

Design Tips:

• Select resistor and capacitor values that achieve your desired cutoff frequency.
• Ensure the capacitor's voltage rating exceeds the maximum input voltage.
• For better accuracy, choose components with tight tolerance values (e.g., 1% resistors).

Circuit: To build a high-pass filter, connect a capacitor (C) in series with a resistor (R). The output is taken across the resistor. The cutoff frequency (f_c) is calculated as: f_c = 1 / (2πRC).
Simple Circuit Diagram:

                    C
             +-----||----+     
             |            |
             |            R
            Vin          /\/\/\  
             |            |
             +------------+
                       Vout
            

This diagram represents the high-pass filter circuit with a capacitor (C) and resistor (R). The input voltage (Vin) is applied to the series combination of C and R, and the output voltage (Vout) is taken across the resistor.

Quick Reference:

• Cutoff Frequency: f_c = 1 / (2πRC)
• Impedance of Capacitor: Z_C = 1 / (2πfC)
• Impedance of Resistor: Z_R = R
• Transfer Function: H(f) = j(f/f_c) / (1 + j(f/f_c))
• Phase Shift: θ(f) = atan(f/f_c)

    import numpy as np
    import matplotlib.pyplot as plt
    
    # Parameters
    f_c = 1590  # Cutoff frequency in Hz for R=10kΩ and C=10nF
    R = 10000   # Resistance in ohms
    C = 10e-9   # Capacitance in farads
    
    # Frequency response
    frequencies = np.logspace(1, 6, 500)
    H = 1j * frequencies / (2 * np.pi * f_c) / (1 + 1j * frequencies / (2 * np.pi * f_c))
    
    plt.figure()
    plt.semilogx(frequencies, 20 * np.log10(abs(H)))
    plt.title('High-Pass Filter Frequency Response')
    plt.xlabel('Frequency (Hz)')
    plt.ylabel('Magnitude (dB)')
    plt.grid(which='both', axis='both')
    plt.show()
            

Design Tips:

• Select resistor and capacitor values that achieve your desired cutoff frequency.
• Ensure the capacitor's voltage rating exceeds the maximum input voltage.
• For better accuracy, choose components with tight tolerance values (e.g., 1% resistors).

Circuit: To build a notch filter, use an RLC circuit where the inductor (L), capacitor (C), and resistor (R) are arranged to resonate at the notch frequency. The notch frequency (f_notch) is determined by the formula: fnotch = 1 / (2π√(LC)).
Simple Circuit Diagram:

               +---- L ----+
               |           |
             Vin          R 
               |           |
               +---- C ----+
                        |
                       GND
            

This diagram represents the notch filter circuit. The inductor (L), resistor (R), and capacitor (C) are arranged in a parallel configuration to create a resonance at the notch frequency. The input voltage (Vin) is applied across the combination, and the output is taken from the same points.

Quick Reference:

• Notch Frequency: fnotch = 1 / (2π√(LC))
• Quality Factor: Q = fnotch / (f2 - f1)
• Bandwidth: BW = f2 - f1
• Impedance of Inductor: ZL = 2πfL
• Impedance of Capacitor: ZC = 1 / (2πfC)
• Transfer Function: H(f) = 1 - (f/fnotch)2 / [(f/fnotch)2 + j(f/Q)(f/fnotch)]

    import numpy as np
    import matplotlib.pyplot as plt
    
    # Parameters
    f_notch = 1000  # Notch frequency in Hz
    BW = 50         # Bandwidth in Hz
    Q = f_notch / BW  # Quality factor
    R = 1000        # Resistance in ohms
    C = 10e-9       # Capacitance in farads
    L = 1 / (C * (2 * np.pi * f_notch)**2)  # Inductance in henries
    
    # Frequency response
    frequencies = np.logspace(1, 6, 500)
    H = 1 - (frequencies**2) / (frequencies**2 + 1j * frequencies / Q * 2 * np.pi * f_notch + (2 * np.pi * f_notch)**2)
    
    plt.figure()
    plt.semilogx(frequencies, 20 * np.log10(abs(H)))
    plt.title('Notch Filter Frequency Response')
    plt.xlabel('Frequency (Hz)')
    plt.ylabel('Magnitude (dB)')
    plt.grid(which='both', axis='both')
    plt.show()
            

Design Tips:

• Choose component values that allow the circuit to resonate at your desired notch frequency.
• A higher quality factor (Q) results in a narrower bandwidth and a sharper notch.
• Ensure that the components can handle the expected voltage and current levels in the circuit.

Application: Kalman filters are commonly used in applications such as:

• Navigation systems (e.g., GPS)
• Robotics for sensor fusion
• Economics and finance for time series forecasting
• Control systems in engineering

Quick Reference:

• State Estimate (x): The current estimate of the state variable.
• Estimate Uncertainty (P): The uncertainty in the current state estimate.
• Process Variance (Q): The variance of the process noise, representing uncertainty in the model.
• Measurement Variance (R): The variance of the measurement noise, representing uncertainty in the measurements.
• Kalman Gain (K): K = P_pred / (P_pred + R) - Determines the weighting of the prediction and the new measurement in updating the estimate.
• Prediction Step: The step where the state and uncertainty are predicted based on the previous state.
• Measurement Update Step: The step where the predicted state is corrected using the new measurement.

        import numpy as np
        
        # Initial conditions
        x = 0  # Initial state estimate
        P = 1  # Initial estimate uncertainty
        Q = 0.1  # Process variance
        R = 1  # Measurement variance
        
        # Kalman Filter function
        def kalman_filter(z, x, P, Q, R):
            # Prediction step (we assume a constant model, so prediction is x itself)
            x_pred = x
            P_pred = P + Q
        
            # Measurement update (correction)
            K = P_pred / (P_pred + R)  # Kalman gain
            x = x_pred + K * (z - x_pred)  # Update estimate with measurement z
            P = (1 - K) * P_pred  # Update uncertainty
        
            return x, P
        
        # Measurements provided
        measurements = [1, 2, 3, 2, 1, 0]
        
        # Applying Kalman filter
        for z in measurements:
            x, P = kalman_filter(z, x, P, Q, R)
            print(f'Measurement: {z}, Updated state estimate: {x:.4f}, Estimate uncertainty: {P:.4f}')
            

        Measurement: 1, Updated state estimate: 0.5000, Estimate uncertainty: 0.5000
        Measurement: 2, Updated state estimate: 1.2500, Estimate uncertainty: 0.3750
        Measurement: 3, Updated state estimate: 2.1429, Estimate uncertainty: 0.3125
        Measurement: 2, Updated state estimate: 2.1176, Estimate uncertainty: 0.2812
        Measurement: 1, Updated state estimate: 1.5294, Estimate uncertainty: 0.2656
        Measurement: 0, Updated state estimate: 1.1463, Estimate uncertainty: 0.2578
            

    import numpy as np
    
    # Kalman Filter implementation for a simple system
    
    # Initial conditions
    x = 0  # Initial state estimate
    P = 1  # Initial estimate uncertainty
    Q = 0.1  # Process variance
    R = 1  # Measurement variance
    
    # Kalman Filter function
    def kalman_filter(z, x, P, Q, R):
        # Prediction step
        x_pred = x  # Predict the state (no change for this simple case)
        P_pred = P + Q  # Update the uncertainty with process variance
    
        # Measurement update step
        K = P_pred / (P_pred + R)  # Calculate the Kalman gain
        x = x_pred + K * (z - x_pred)  # Update the estimate with measurement z
        P = (1 - K) * P_pred  # Update the estimate uncertainty
    
        return x, P
    
    # Example usage
    measurements = [1, 2, 3, 2, 1, 0]
    for z in measurements:
        x, P = kalman_filter(z, x, P, Q, R)
        print(f'Updated state estimate: {x:.2f}, Estimate uncertainty: {P:.2f}')
            

Explanation:

The Kalman filter works by iteratively predicting the state of the system and then updating this prediction using new measurements. In the prediction step, the state estimate is propagated forward, and the uncertainty increases due to the process noise. In the measurement update step, the prediction is corrected based on the new measurement, with the Kalman gain determining how much to trust the new measurement versus the prediction.

For this simple system, the process is straightforward, but the same principles apply to more complex systems with multiple states and measurements.

Design Tips:

• Choose the process variance (Q) and measurement variance (R) carefully to balance the response of the filter. A low Q makes the filter slow to respond to changes, while a high Q makes it more reactive but possibly too sensitive to noise.
• Ensure that the Kalman gain is calculated correctly as it directly affects the update step.
• Kalman filters can be extended to non-linear systems using the Extended Kalman Filter (EKF) or Unscented Kalman Filter (UKF).

Circuit: To build a Butterworth filter, you'll need to cascade multiple stages of active filters, typically using operational amplifiers (op-amps). For an nth-order Butterworth filter, n stages are cascaded. Each stage is a second-order (biquad) filter with a specific Q factor and cutoff frequency. The cutoff frequency (f_c) for each stage can be calculated using standard filter design formulas.

Quick Reference:

• Order (N): The order of the filter determines the slope of the attenuation beyond the cutoff frequency. A higher order results in a steeper slope.
• Cutoff Frequency (f_c): The frequency at which the output signal is reduced to 70.7% of the input signal (i.e., -3 dB point).
• Q Factor: Determines the sharpness of the resonance peak for each stage of the filter.
• Biquad Filter: Each stage of the Butterworth filter is a biquad filter, which is a second-order filter with two poles.
• Normalized Cutoff Frequency (Wn): This is the cutoff frequency normalized to the Nyquist frequency in digital filter design.

Wn = f_c / (fs / 2)

Wn = 1000 / (8000 / 2) = 0.25

        import numpy as np
        import scipy.signal as signal
        import matplotlib.pyplot as plt
        
        # Parameters
        N = 4        # Filter order
        f_c = 1000   # Cutoff frequency in Hz
        fs = 8000    # Sampling frequency in Hz
        Wn = f_c / (fs / 2)  # Normalized cutoff frequency (0 to 1, where 1 corresponds to Nyquist frequency)
        
        # Butterworth filter design
        b, a = signal.butter(N, Wn, 'low')
                

        w, h = signal.freqz(b, a, worN=8000)
                

        plt.figure()
        plt.plot((w / np.pi) * (fs / 2), 20 * np.log10(abs(h)))
        plt.title('Butterworth Filter Frequency Response')
        plt.xlabel('Frequency (Hz)')
        plt.ylabel('Magnitude (dB)')
        plt.grid()
        plt.show()
                

    import numpy as np
    import scipy.signal as signal
    import matplotlib.pyplot as plt
    
    # Parameters
    N = 4        # Filter order
    f_c = 1000   # Cutoff frequency in Hz
    fs = 8000    # Sampling frequency in Hz
    Wn = f_c / (fs / 2)  # Normalized cutoff frequency (0 to 1, where 1 corresponds to Nyquist frequency)
    
    # Butterworth filter design
    b, a = signal.butter(N, Wn, 'low')
    w, h = signal.freqz(b, a, worN=8000)
    
    plt.figure()
    plt.plot((w / np.pi) * (fs / 2), 20 * np.log10(abs(h)))
    plt.title('Butterworth Filter Frequency Response')
    plt.xlabel('Frequency (Hz)')
    plt.ylabel('Magnitude (dB)')
    plt.grid()
    plt.show()
            

Explanation:

The Butterworth filter is designed by first determining the filter order (N) and the desired cutoff frequency (f_c). The filter is implemented by cascading multiple second-order filter stages, each designed to contribute to the overall filter's flat passband. The design ensures that the frequency response is maximally flat (no ripples) within the passband, making the Butterworth filter ideal for applications where signal fidelity is critical.

The calculation of the component values for each stage involves solving filter design equations that consider the desired cutoff frequency and the filter's order. These values are then used to construct the analog filter stages, typically using op-amps, resistors, and capacitors. For digital implementations, the filter coefficients (b, a) are calculated using signal processing libraries like SciPy in Python.

This filter is widely used in applications requiring a smooth and predictable frequency response, such as audio processing and control systems.

Design Tips:

• Ensure that the filter order (N) is chosen based on the required sharpness of the cutoff. Higher orders provide steeper roll-offs but may introduce more complexity and phase distortion.
• Use simulation tools to verify the frequency response of the designed filter before implementing it in hardware or software.
• For digital implementations, always consider the sampling frequency and ensure that the Nyquist criterion is satisfied.
• In analog implementations, ensure that the op-amps used have sufficient bandwidth to handle the frequencies involved in the filter design.