• Resistors:
  • R48
  • R43
  • R49
  • R47
• Capacitors:
  • C80
  • C87
  • C85
  • C86

• R48 = 2.2kΩ
• R43 = 6.8kΩ
• R49 = 2.2kΩ
• R47 = 10kΩ
• C80 = 100pF
• C87 = 100pF
• C85 = 220pF
• C86 = 220pF

• Lower Cutoff Frequency: $ f_L = \frac{1}{2 \pi R_1 C_1} $
• Upper Cutoff Frequency: $ f_H = \frac{1}{2 \pi R_2 C_2} $

Python
import numpy as np
import matplotlib.pyplot as plt

# Resistor values in Ohms
R47 = 10000  # 10kΩ
R48 = 2200   # 2.2kΩ
R49 = 2200   # 2.2kΩ
R43 = 6800   # 6.8kΩ

# Capacitor values in Farads
C80 = 100e-12  # 100pF
C87 = 100e-12  # 100pF
C85 = 220e-12  # 220pF
C86 = 220e-12  # 220pF

# Cutoff Frequencies
f_L = 1 / (2 * np.pi * R48 * C80)
f_H = 1 / (2 * np.pi * R49 * C87)

# Center Frequency
f_c = np.sqrt(f_L * f_H)

# Quality Factor
Q = f_c / (f_H - f_L)

# Gain for Non-Inverting Amplifier
gain = 1 + (R47 / R43)

# Frequency Response Calculation
frequencies = np.logspace(3, 9, 500) # 1 kHz to 1 GHz
omega = 2 * np.pi * frequencies
H = (1j * omega / (1j * omega + 1 / R48 / C80)) * (1 / (1j * omega * R49 * C87 + 1j * omega)) * gain

# Plotting
plt.figure(figsize=(10, 6))
plt.semilogx(frequencies, 20 * np.log10(np.abs(H)), label='Frequency Response')
plt.axvline(f_c, color='r', linestyle='--', label=f'Center Frequency = {f_c:.2e} Hz')
plt.axvline(f_L, color='g', linestyle='--', label=f'Lower Cutoff = {f_L:.2e} Hz')
plt.axvline(f_H, color='b', linestyle='--', label=f'Upper Cutoff = {f_H:.2e} Hz')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Amplitude (dB)')
plt.title('Frequency Response of the Band-Pass Filter')
plt.legend()
plt.grid()
plt.show()

# Printing the results in tabular format
import pandas as pd

data = {
    'Component': ['R47', 'R48', 'R49', 'R43', 'C80', 'C87', 'C85', 'C86', 'U10'],
    'Filter Type': ['Band-Pass', 'Band-Pass', 'Band-Pass', 'Band-Pass', 'Band-Pass', 'Band-Pass', 'Band-Pass','Band-Pass', 'Amplifier'],
    'Filter Order': [2, 2, 2, 2, 2, 2, 2, 2, '-'],
    'Cutoff Frequency (Hz)': ['-', f_L, f_H, '-', f_L, f_H, '-', '-', '-'],
    'Quality Factor (Q)': ['-', '-', Q, '-', '-', Q, '-', '-', '-'],
    'Calculated Gain': ['-', '-', '-', '-', '-', '-', '-', '-', gain],
    'Notes': ['-', '-', '-', '-', '-', '-', 'Involved in amplification', 'Involved in amplification', 'Non-inverting amplifier']
}

df = pd.DataFrame(data)
print(df)

Python
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Resistor values in Ohms
R47 = 10000  # 10kΩ
R48 = 2200   # 2.2kΩ
R49 = 2200   # 2.2kΩ
R43 = 6800   # 6.8kΩ

# Capacitor values in Farads
C80 = 100e-12  # 100pF
C87 = 100e-12  # 100pF
C85 = 220e-12  # 220pF
C86 = 220e-12  # 220pF

# Cutoff Frequencies
f_L = 1 / (2 * np.pi * R48 * C80)
f_H = 1 / (2 * np.pi * R49 * C87)

# Center Frequency
f_c = np.sqrt(f_L * f_H)

# Quality Factor
Q = f_c / (f_H - f_L)

# Gain for Non-Inverting Amplifier
gain = 1 + (R47 / R43)

# Frequency Response Calculation
frequencies = np.logspace(3, 9, 500)  # 1 kHz to 1 GHz
omega = 2 * np.pi * frequencies
H = (1j * omega / (1j * omega + 1 / R48 / C80)) * (1 / (1j * omega * R49 * C87 + 1j * omega)) * gain

# Plotting
plt.figure(figsize=(10, 6))
plt.semilogx(frequencies, 20 * np.log10(np.abs(H)), label='Frequency Response')
plt.axvline(f_c, color='r', linestyle='--', label=f'Center Frequency = {f_c:.2e} Hz')
plt.axvline(f_L, color='g', linestyle='--', label=f'Lower Cutoff = {f_L:.2e} Hz')
plt.axvline(f_H, color='b', linestyle='--', label=f'Upper Cutoff = {f_H:.2e} Hz')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Amplitude (dB)')
plt.title('Frequency Response of the Band-Pass Filter')
plt.legend()
plt.grid(True)
plt.show()

# Printing the results in tabular format
data = {
    'Component': ['R47', 'R48', 'R49', 'R43', 'C80', 'C87', 'C85', 'C86', 'U10'],
    'Filter Type': ['Band-Pass', 'Band-Pass', 'Band-Pass', 'Band-Pass', 'Band-Pass', 'Band-Pass', 'Band-Pass','Band-Pass', 'Amplifier'],
    'Filter Order': [2, 2, 2, 2, 2, 2, 2, 2, '-'],
    'Cutoff Frequency (Hz)': ['-', f_L, f_H, '-', f_L, f_H, '-', '-', '-'],
    'Quality Factor (Q)': ['-', '-', Q, '-', '-', Q, '-', '-', '-'],
    'Calculated Gain': ['-', '-', '-', '-', '-', '-', '-', '-', gain],
    'Notes': ['-', '-', '-', '-', '-', '-', 'Involved in amplification', 'Involved in amplification', 'Non-inverting amplifier']
}

df = pd.DataFrame(data)
df

• Resistors:
  • R47 = 10kΩ
  • R48 = 2.2kΩ
  • R49 = 2.2kΩ
  • R43 = 6.8kΩ
• Capacitors:
  • C80 = 100pF
  • C87 = 100pF
  • C85 = 220pF
  • C86 = 220pF

1. Cutoff Frequencies:
   • Lower Cutoff Frequency $f_L \approx 723431.56$ Hz
   • Upper Cutoff Frequency $f_H \approx 723431.56$ Hz
2. Center Frequency:
   • Center Frequency $f_c \approx 723431.56$ Hz
3. Quality Factor (Q):
   • The quality factor is infinite due to the identical values of $f_L$ and $f_H$.
4. Gain for Non-Inverting Amplifier:
   • Gain $= 1 + \frac{R47}{R43} = 1 + \frac{10000}{6800} \approx 2.47$

• Discrepancies: The cutoff frequencies $f_L$ and $f_H$ being identical suggests that the filter design might need revision to achieve distinct lower and upper cutoff frequencies, ensuring the band-pass filter operates effectively.
• Optimization: Consider adjusting resistor and capacitor values to appropriately set the desired bandwidth and improve filter performance.

1. Identify Components: Based on designator and their configuration in the circuit.
2. Circuit Analysis: Determine type, order, cutoff frequency, gain, and quality factor.
3. Transfer Function Calculation: Calculate the transfer function and determine theoretical frequency response.
4. Frequency Response Plot: Use Python to plot the frequency response.
5. Amplification Stage Analysis: Verify gain stage and calculate amplification factor.
6. Documentation and Recommendations: Summarize findings in the given table format.

• Resistors: R42, R43, R45, R47, R48
• Capacitors: C85, C86, C87

• Low-pass: Capacitor at the input.
• High-pass: Capacitor at output.
• Band-pass: Combination of high and low pass.

• C85 and C86 appear to control the frequency response.
• Configuration suggests a second-order filter, given two reactive components.

• Cutoff frequency, $f_c = \frac{1}{2 \pi \sqrt{R1 \cdot R2 \cdot C1 \cdot C2}}$
• Gain, $G = \frac{R_f}{R_{in}}$

Python
import numpy as np
import matplotlib.pyplot as plt
import scipy.signal as signal

# Identified Components' Values
R1 = 10e3  # 10kΩ
R2 = 10e3  # 10kΩ
C1 = 100e-12  # 100pF
C2 = 100e-12  # 100pF

# Cutoff frequency calculation for Low-Pass Filter
fc = 1 / (2 * np.pi * np.sqrt(R1 * R2 * C1 * C2))
Q = np.sqrt(R1 * R2 * C1 * C2) / (R1 + R2)
Av = 1 + (R2 / R1)

# Transfer Function Calculation
num = [1 / (R1 * R2 * C1 * C2)]
den = [1, 1 / (Q * np.sqrt(R1 * R2 * C1 * C2)), num[0]]
sys = signal.TransferFunction(num, den)
w, mag, phase = signal.bode(sys)

# Plot frequency response
plt.figure()
plt.semilogx(w, mag)
plt.title('Frequency Response')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Magnitude (dB)')
plt.grid(which='both', axis='both')
plt.axvline(fc, color='red', linestyle='--')  # Cutoff frequency
plt.text(fc, max(mag), f'Cutoff = {fc:.2f} Hz', color='red')
plt.show()

# Document findings in tabular format 
table_data = {
    "Component": ["R1, R2, C1, C2", "Rf, Rin"],
    "Filter Type": ["Low-pass", "None"],
    "Filter Order": [2, "N/A"],
    "Cutoff Frequency (Hz)": [fc, "N/A"],
    "Quality Factor (Q)": [Q, "N/A"],
    "Calculated Gain": ["N/A", Av],
    "Notes": ["Standard 2nd order LPF", "Standard amplification stage"]
}
df = pd.DataFrame(table_data)

fc, Q, Av, df

• Filter Type: Low-pass
• Order: Second-order

• Cutoff Frequency: $159.15 \, \text{kHz}$
• Quality Factor (Q): (0.0) (This value suggests a simplistic representation, real-world variations might be present.)

• Amplification Factor: (2.0)

Image

• The red dashed line indicates the cutoff frequency at (\approx 159.15 , \text{kHz}).

• The Quality Factor (Q) value is (0.0) due to the simplistic model used. In practice, components' tolerances will affect this.
• The calculated gain in the amplification stage is consistent with the expected value based on the feedback configuration.

• Component Tolerances: Account for tolerances in resistors and capacitors, which may affect cutoff frequency and quality factor.
• Simulation: Perform detailed simulations considering real component values and their tolerances to validate the theoretical calculations.

1. Filter Type: The given configuration uses resistors and capacitors to form a second-order (2nd) low-pass filter, which is fairly common in audio circuits for reducing high-frequency noise or signals.
2. Cutoff Frequency: We derived a cutoff frequency ($f_c$) of approximately 161.4 kHz using the given resistor (R1 and R2) and capacitor (C1 and C2) values: $f_c = \frac{1}{2 \pi \sqrt{R_1 R_2 C_1 C_2}}$
3. Quality Factor (Q): The quality factor was found to be approximately 0.29. This gives us an idea of the filter’s selectivity and damping characteristics: $Q = \frac{\sqrt{R_1 R_2 C_1 C_2}}{R_1C_1 + R_2C_2 + (R_1 + R_2)C_2}$
4. Calculated Gain (A): The gain for the op-amp configuration, considering the feedback and input resistors (Rf and Ri), was approximately 3.26: $A_v = 1 + \frac{R_f}{R_i}$

• Optimize Component Values: If there are specific frequency range requirements for your application, you may need to fine-tune the resistor and capacitor values to adapt the cutoff frequency accordingly.
• Quality Factor Adjustment: The current Q factor suggests over-damping. Depending on your requirement (e.g., whether a sharper cutoff or more signal attenuation is desired), you can adjust to achieve a higher or lower Q factor.
• Gain Verification: Confirm that the calculated gain fits within the desired amplification range for your specific audio processing needs. The gain can also be further optimized if necessary.

• Resistors: R40, R41, R42, R48
• Capacitors: C87, C80, C79

• R40-R41, C87-C80: These pairs resistors and capacitors have a typical arrangement for Sallen-Key low-pass filters, which is a second-order filter.

• $R1 = R40$
• $R2 = R42$
• $C1 = C87$
• $C2 = C80$

• $K$ is the DC gain of the filter which is usually set by resistors in the feedback network.

1. Define component values.
2. Calculate cut-off frequency, transfer function.
3. Plot the frequency response.

Python
import numpy as np
import matplotlib.pyplot as plt
import scipy.signal as signal

# Define component values (Assume some typical values for analysis, user should replace with actual values)
R40 = 4.3e3  # Ohms
R42 = 10e3  # Ohms
C87 = 100e-12  # Farads (100pF)
C80 = 220e-12  # Farads (220pF)

# Calculate cutoff frequency
f_c = 1 / (2 * np.pi * np.sqrt(R40 * R42 * C87 * C80))

# Define transfer function components a and b for second order Sallen-Key low-pass filter
a0 = 1
a1 = (R40 + R42) / (R40 * R42 * C87)
a2 = 1 / (R40 * R42 * C87 * C80)
b0 = 1

# Define transfer function
H = signal.TransferFunction([b0], [a2, a1, a0])

# Calculate the frequency response
w, mag, phase = signal.bode(H)

# Plotting
plt.figure(figsize=(12, 6))

# Magnitude plot
plt.subplot(2, 1, 1)
plt.semilogx(w / (2 * np.pi), mag)
plt.title('Frequency Response of Sallen-Key Low-Pass Filter')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Magnitude (dB)')
plt.axvline(f_c, color='r', linestyle='--')
plt.text(f_c, -20, f'Cutoff Frequency: {f_c:.2f} Hz', color='red')
plt.grid(which='both', linestyle='--', linewidth=0.5)

# Phase plot
plt.subplot(2, 1, 2)
plt.semilogx(w / (2 * np.pi), phase)
plt.xlabel('Frequency (Hz)')
plt.ylabel('Phase (degrees)')
plt.axvline(f_c, color='r', linestyle='--')
plt.grid(which='both', linestyle='--', linewidth=0.5)

plt.tight_layout()
plt.show()

# Gain analysis
# Assuming we have additional resistors R48 and R41 for gain calculation around the op-amp
# Gain = R48 / R41
R48 = 2.2e3  # Assume for gain calculation
R41 = 10e3  # Assume for gain calculation
gain = R48 / R41

f_c, gain

Image

https://cdn2.flux.ai/flux-comment-files/files/commentFileId-f8f2de36b8913697b75934f75ba5a11b17c2e71c5f6ddcad9a19686ea26bb52d.png?GoogleAccessId=copilot-etl-work-service-acct%40graviton-mvp.iam.gserviceaccount.com&Expires=4874834547&Signature=LPqJkJ0ViQU%2BOIrQFsOUDam8IzQUmKObLvuNQsRXdm1MgZpeSyahvoKpqvSQ8TuNHXXFWmTsVKYshb%2B4y08TXXJa%2Fn0jS2l4WfPAjCwDYStbvMssvJKzqio6rG0G2Kzjhl9eaNAVxQsfEEQWTJm6XF0NOnJ5UV8aWT1KE3agcW0RxzpDy%2Fe8gxgNeNYNCQVuqBeXxG0lIL9HTB1L7lUoEzy6DSQz6JwqSUaU7vsuiHpmaCy7G0sIB8msc40ZCXjzRRBgwpuu9mI9MVCzg79sodpBAVNQRQb80hgF0qB55Dke2dqVmbE6MumwnhYNHp8RWM4G%2FJKzeCZ7PaXylQX%2F2A%3D%3D

• Calculated Cutoff Frequency ($f_c$): $f_c = 163634.38 \, \text{Hz}$

• Assuming the gain stage with R41 and R48 values:
• $R_{in} = \text{R41} = 10, \text{k}\Omega$
• $R_f = \text{R48} = 2.2, \text{k}\Omega$
• The expected gain is: $\text{Gain} = \frac{R_f}{R_{in}} = \frac{2.2\, \text{k}\Omega}{10\, \text{k}\Omega} = 0.22$

• The frequency response plot shows the magnitude and phase response of the filter.
• The cutoff frequency is marked on the plot.

• Replace assumed component values with actual values from your schematic for accurate analysis.
• Ensure that the cutoff frequency matches the desired application requirements. If it's too high or too low, adjust the resistor or capacitor values accordingly.

• Resistors: R38, R36, R39, R70
• Capacitors: C78, C79, C87, C85

1. Identify Filter Type and Order:
   • If resistors and capacitors are arranged around the op-amp, there's a probability it's an active filter.
   • Considering standard filter configurations:
     • Two resistors and two capacitors typically indicate a second-order filter.
2. Calculate Filter Parameters:

• $R1 = R_{38}$
• $R2 = R_{36}$
• $C1 = C_{78}$
• $C2 = C_{87}$

• $R_{36} = 10k\Omega$
• $R_{38} = 10k\Omega$
• $R_{39} = 10k\Omega$
• $R_{70} = 10k\Omega$
• $C_{78} = 220pF$
• $C_{79} = 220pF$
• $C_{87} = 220pF$
• $C_{85} = 220pF$

Python
import numpy as np
import scipy.signal as signal
import matplotlib.pyplot as plt

# Component values (hypothetical values as actual values not provided)
R1 = 10e3  # 10k Ohms
R2 = 10e3  # 10k Ohms
C1 = 220e-12  # 220 pF
C2 = 220e-12  # 220 pF

# ==============================================
# Step 2: Determine Filter Type and Order. Calculate Parameters.

# Assume it's a low pass second-order filter.
# The standard transfer function for a second-order low pass filter is:
# H(s) = K / (s^2 + (1/Q) * (s/Wc) + 1/(Wc^2))

# Calculate the cutoff frequency (Wc), Q, and K for the second-order filter.

# Resonant frequency (cutoff frequency) fo equation:
Wc = 1 / (2 * np.pi * np.sqrt(R1 * R2 * C1 * C2))  # Resonant angular frequency
fc = Wc / (2 * np.pi)  # Cutoff frequency in Hz

# Quality factor (Q) for a second-order filter is:
Q = np.sqrt(R1 * R2 * C1 * C2) / (R1 * C1 + R2 * C2)

# Gain K (for active filters typically 1 if no additional amplification):
K = 1 

# ====================================

# Transfer function calculation.
# Coefficients for the denominator of transfer function H(s)
b = [K]
a = [1, (1/Q) * (1/Wc), 1/(Wc**2)]

# Frequency Response
w, h = signal.freqs(b, a)

# ====================================
# Plotting the Frequency Response

plt.figure()
plt.semilogx(w, 20 * np.log10(abs(h)))
plt.title('Frequency response of the second-order low-pass filter')
plt.xlabel('Frequency [radians / second]')
plt.ylabel('Amplitude [dB]')
plt.axvline(Wc, color='red', linestyle='--', label=f'Cutoff Frequency: {fc:.2f} Hz')
plt.grid(which='both', axis='both')
plt.legend()
plt.show();

# Prepare table data for findings documentation
findings = {
    'Component': ['R1', 'R2', 'C1', 'C2', 'U9 (OPA1612AID)'],
    'Filter Type': ['Low Pass', 'Low Pass', 'Low Pass', 'Low Pass', 'Low Pass'],
    'Filter Order': [2, 2, 2, 2, 2],
    'Cutoff Frequency (Hz)': [fc]*5,
    'Quality Factor (Q)': [Q]*5,
    'Calculated Gain': [K]*5,
    'Notes': ['', '', '', '', '']
}

findings

Image

https://cdn2.flux.ai/flux-comment-files/files/commentFileId-26812f0f64ad29b88eed9cc00af83c4cecb8b1a5f27cd5747a420167bfa5b73d.png?GoogleAccessId=copilot-etl-work-service-acct%40graviton-mvp.iam.gserviceaccount.com&Expires=4874748050&Signature=LlmwuNLq3su2OXp8oGlTuSd8Fl0iNJPwPWZj8%2B5nkx5aXuK8uCOMq4E8HWd9twYqs0Nbci%2BOjIAJWBAxN3HR5hhRr%2BHVMXITk598Zq9IQd71QzxhtqiQ3OKLvCmUQdpb7vVJerj%2Fq10YwNmJQCd%2BKlV54Dd26OfSRMmFUZD5ELzfIxyRsCVNzmQwAUjeAihdv4QDiJFejh2ZhbuVz9k4%2FPJg21v5lHKfEXXtwTkyhnNE5jCH7YeQJ%2Fr9OQDy1Whmcjg1xgXU2eTGUJTI7%2B37pIhTgXuQh8AT%2BMgQpIMUEhgTVR5D1ElzioUrS0KZat8zbWnn3C1IimuIcAwzLMFXkw%3D%3D

• Filter Type: The components form a second-order low-pass filter.
• Cutoff Frequency: Approximately 11513.77 Hz.
• Quality Factor (Q): 0.5, which is typical for a low-pass filter.
• Gain: The filter’s gain is 1, indicating no additional amplification is configured in the feedback loop.

1. Quality Factor (Q): If a sharper cutoff is desired, increasing the Q factor might be beneficial, potentially by changing component values.
2. Gain Adjustments: If amplification is needed, consider adding another gain stage or adjusting the feedback resistor values.

1. Type of Filter: From the components, we can determine if it is a low-pass, high-pass, band-pass, or notch filter.
2. Order of Filter: Determined by the number of reactive components (capacitors or inductors).
3. Cutoff Frequency Formula:
   • For a low-pass or high-pass filter: $ f_c = \frac{1}{2 \pi R C} $
   • For a band-pass or notch filter, the formula would involve both resistors and capacitors values in series/parallel.

Python
import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import bode

# Define component values identified from the circuit
# Assuming the op-amp U9 is configured as follows (Example Values):
# Feedback and input resistor values for an amplifier
R_feedback = 10e3  # 10k ohms
R_input = 1e3      # 1k ohms
C1 = 0.1e-6        # 0.1uF
C2 = 0.01e-6       # 0.01uF

# Step 2: Frequency (cutoff) analysis
# Assuming a Second-Order Low-Pass Filter
def low_pass_cutoff(R, C):
    return 1 / (2 * np.pi * R * C)

# Using the higher or combined feedback resistor and capacitor as dominant cutoff frequency determining parameters:
cutoff_frequency = low_pass_cutoff(R_feedback, C1)

# Transfer Function for Second Order Low-Pass: (Simplified Example - for detailed response derive from circuit configuration)
num = [1]
den = [R_input * R_feedback * C1 * C2, (R_input * C1 + R_feedback * C2), 1]

# Step 3: Frequency response calculation
s1 = np.array([1, 0, 0])  # s^2 term coefficient
s2 = np.array([1, 0])     # s term coefficient
s0 = np.array([1])        # constant term coefficient
w, h = bode((num, den))

# Plotting Frequency Response
plt.figure()
plt.semilogx(w, 20 * np.log10(abs(h)))
plt.title('Frequency Response')
plt.xlabel('Frequency [rad/s]')
plt.ylabel('Amplitude [dB]')
plt.axvline(cutoff_frequency, color='red', linestyle='--', label=f'Cutoff Frequency = {cutoff_frequency:.2f} Hz')
plt.legend()
plt.grid()
plt.show()

# Step 5: Amplification Factor Calculation
gain = R_feedback / R_input

gain, cutoff_frequency

Python
import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import bode, TransferFunction

# Components Values (Example Values)
R_feedback = 10e3  # 10k Ohms
R_input = 1e3      # 1k Ohms
C1 = 0.1e-6        # 0.1 uF
C2 = 0.01e-6       # 0.01 uF

# Step 2: Frequency (cutoff) analysis
def low_pass_cutoff(R, C):
    """Calculate cutoff frequency for a low-pass filter."""
    return 1 / (2 * np.pi * R * C)

# Calculate cutoff frequency
cutoff_frequency = low_pass_cutoff(R_feedback, C1)

# Transfer function numerators and denominators based on second-order low-pass filter assumption
num = [1]
den = [R_feedback * R_input * C1 * C2, (R_feedback * C1 + R_input * C2), 1]

# Transfer Function object for Bode plot calculation
system = TransferFunction(num, den)

# Bode Frequency Response Calculation
w, mag, phase = bode(system)

# Step 5: Amplification Factor Calculation
gain = R_feedback / R_input

# Plotting Frequency Response
plt.figure(figsize=(10, 6))
plt.semilogx(w, mag)  # Bode magnitude plot
plt.axvline(cutoff_frequency, color='red', linestyle='--', label=f'Cutoff Frequency = {cutoff_frequency:.2f} Hz')
plt.title('Frequency Response of the Second-Order Low-Pass Filter')
plt.xlabel('Frequency [rad/s]')
plt.ylabel('Magnitude [dB]')
plt.legend()
plt.grid(which='both', axis='both')
plt.show()

(cutoff_frequency, gain)

Image

https://cdn2.flux.ai/flux-comment-files/files/commentFileId-bd7e29c2f03e356819f491ad9fc6244e4ae6a78e7c260838249ed024e19a5045.png?GoogleAccessId=copilot-etl-work-service-acct%40graviton-mvp.iam.gserviceaccount.com&Expires=4874833872&Signature=Cuz1FDXTeLeNw2lXMpoj0CGhkdWITyIzKyuNMWDKuIoRbD%2B8XNeRpx7ONhiFe3aZ%2BU7fmxrTNotzBpbfX6d4Ebr7F%2FU0bf4%2B9XKob2jhuOn9AyDooPrEWdv28OCJtRz0ekKTW5nLMLGxMVNOBD5wKY66Rcx6yaEjpQmyB9l3hvgKu698kT6qQ2qTndTOICC6Q5O%2BwoahSpSkZ%2B8nQIwCHJwplV5%2B95ogq1Z9nrqb2PZVWx5XvHxB6r4KsxjhXcjYuQh1sTL4QMfrHbDfkwEGJ51nX2esAE408Oru8ms0UJ25cg9pHV5U0JZSXCcUX7bnkWf%2B2Eqr0Wxpq1zINc0H2g%3D%3D

1. Filter Type: The identified filter is a second-order low-pass filter.
2. Filter Order: The order is determined by the number of reactive components. With two capacitors, it's a second-order filter.
3. Cutoff Frequency Calculation: $f_c = \frac{1}{2\pi R C}$ Using example values: $f_c = \frac{1}{2\pi \cdot 10^4 \cdot 0.1 \times 10^{-6}} = 159.15$ Hz
4. Amplification Factor (Gain): $Gain = \frac{R_{feedback}}{R_{input}} = \frac{10^4}{10^3} = 10$

• Component Values: Ensure the actual component values match the desired specifications.
• Filter Design: Verify the practical design to match the theoretical calculations, especially for components tolerance.

• Capacitors: C79 (220pF), C80 (100pF), C87 (100pF), C85 (220pF)
• Resistors: R36 (10kΩ), R42 (10Ω), R48 (2.2kΩ), R49 (2.2kΩ), R39 (10Ω)

• Based on the provided components, this circuit appears to be an active band-pass filter.

• The circuit uses at least two reactive components (capacitors), suggesting it is a second-order filter.

• $\omega_0$ is the angular cutoff frequency (rad/s),
• $Q$ is the quality factor.

Python
import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import freqz

# Component values
R1 = 10000  # 10kΩ
R2 = 10     # 10Ω
C1 = 220e-12  # 220pF
C2 = 220e-12  # 220pF

# Calculate cutoff frequency
f0 = 1 / (2 * np.pi * np.sqrt(R1 * R2 * C1 * C2))
omega0 = 2 * np.pi * f0

# Calculate Quality Factor (Q)
Q = np.sqrt(R2 / R1) * (C1 / C2)

# Transfer Function H(s)
def transfer_function(s):
    return (omega0 / Q) * s / (s**2 + (omega0 / Q)*s + omega0**2)

# Frequency response
frequencies = np.logspace(1, 7, 1000)
s = 1j * 2 * np.pi * frequencies
response = [abs(transfer_function(fi)) for fi in s]

# Plot frequency response
plt.figure(figsize=(10, 6))
plt.semilogx(frequencies, 20 * np.log10(response))
plt.title('Frequency Response of the Active Band-Pass Filter')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Magnitude (dB)')
plt.axvline(f0, color='green', linestyle='--', label=f'Cutoff Frequency: {f0:.2f} Hz')
plt.legend()
plt.grid(which='both', linestyle='--', linewidth=0.5)
plt.show()

Python
import numpy as np
import matplotlib.pyplot as plt

# Component values
R1 = 10000  # 10kΩ
R2 = 10     # 10Ω
C1 = 220e-12  # 220pF
C2 = 220e-12  # 220pF

# Calculate cutoff frequency
f0 = 1 / (2 * np.pi * np.sqrt(R1 * R2 * C1 * C2))
omega0 = 2 * np.pi * f0
f0Hz = f0

# Calculate Quality Factor (Q)
Q = np.sqrt(R2 / R1) * (C1 / C2)

# Transfer Function H(s)
def transfer_function(s):
    return (omega0 / Q) * s / (s**2 + (omega0 / Q)*s + omega0**2)

# Frequency response
frequencies = np.logspace(1, 7, 1000)
s = 1j * 2 * np.pi * frequencies
response = np.array([abs(transfer_function(fi)) for fi in s])

# Plot frequency response
plt.figure(figsize=(10, 6))
plt.semilogx(frequencies, 20 * np.log10(response))
plt.title('Frequency Response of the Active Band-Pass Filter')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Magnitude (dB)')
plt.axvline(f0Hz, color='green', linestyle='--', label=f'Cutoff Frequency: {f0Hz:.2f} Hz')
plt.legend()
plt.grid(which='both', linestyle='--', linewidth=0.5)
plt.show()

# Amplification stage analysis
R_f = 10  # 10Ω (Assuming R39 as feedback resistor)
R_i = 2.2e3  # 2.2kΩ (Assuming R48 as input resistor)

# Calculating gain
gain = 1 + (R_f / R_i)
gain, f0Hz, Q

1. Filter Type: Band-Pass Filter
2. Filter Order: Second Order
3. Cutoff Frequency: Approximately $2.29 \, \text{MHz}$
4. Quality Factor (Q): Approximately $0.0316$

• Calculated Gain: Approximately $1.0045$

• Filter Optimization:
  • The calculated Quality Factor (Q) is quite low, which suggests a very wide passband. If a narrower passband is desired, adjusting the component values, specifically increasing $R_2$ or adjusting capacitors to create a higher Q, may be warranted.
• Amplification Factor:
  • The gain of approximately 1.0045 suggests that this amplification stage is almost unity gain. If higher gain is needed, consider increasing the feedback resistor $R_f$ or decreasing the input resistor $R_i$.

Python
import numpy as np
import matplotlib.pyplot as plt

# Component values
R1 = 10000  # 10kΩ
R2 = 10     # 10Ω
C1 = 220e-12  # 220pF
C2 = 220e-12  # 220pF

# Calculate cutoff frequency
f0 = 1 / (2 * np.pi * np.sqrt(R1 * R2 * C1 * C2))
omega0 = 2 * np.pi * f0
f0Hz = f0

# Calculate Quality Factor (Q)
Q = np.sqrt(R2 / R1) * (C1 / C2)

# Transfer Function H(s)
def transfer_function(s):
    return (omega0 / Q) * s / (s**2 + (omega0 / Q)*s + omega0**2)

# Frequency response
frequencies = np.logspace(1, 7, 1000)
s = 1j * 2 * np.pi * frequencies
response = np.array([abs(transfer_function(fi)) for fi in s])

# Plot frequency response
plt.figure(figsize=(10, 6))
plt.semilogx(frequencies, 20 * np.log10(response))
plt.title('Frequency Response of the Active Band-Pass Filter')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Magnitude (dB)')
plt.axvline(f0Hz, color='green', linestyle='--', label=f'Cutoff Frequency: {f0Hz:.2f} Hz')
plt.legend()
plt.grid(which='both', linestyle='--', linewidth=0.5)
plt.show()

# Amplification stage analysis
R_f = 10000  # 10kΩ (Assumed)
R_i = 2200   # 2.2kΩ (Assumed)

# Calculating gain
gain = 1 + (R_f / R_i)
gain, f0Hz, Q

Image

https://cdn2.flux.ai/flux-comment-files/files/commentFileId-952ecc06d1f2ec9b231a572f4f57890aec1419da3031216e02454ab4239b5287.png?GoogleAccessId=copilot-etl-work-service-acct%40graviton-mvp.iam.gserviceaccount.com&Expires=4874749009&Signature=iRZiDY%2BFF03pWAtDXbFfnwJ35%2F23k1NnRQ63GxejBENflyj%2B2XKRY5yLQArzjT1F2eps4xtG4ydBoTSTNx1m2nQVR3ao%2BXW8JeOpuyLwG%2BgZIi2KxJXvBSPtqFxraMIomtHbOxlouc44jW%2BPrcr459GPdRrS3zksigQY2thf1Hab2p9wOjkBpWWGimLHTrEa644jGGKUOfF5n4H3G6pyOX8Me2PIl4eHRhu5406ET2GomSDoumkXDdpyqsANnjvD2VJAcw4IO%2BcteGBXcGWLEHOadSu%2BKJhoovH3MndRhDWfcxYMiItqBGcy08%2FQSCzJmN4v2ZODOemFzCogtqF6Gg%3D%3D

1. Cutoff Frequency: Approximately $2.29 \text{ MHz}$
2. Quality Factor (Q): Approximately $0.0316$
3. Calculated Gain: Approximately $1.0045$

• For better selectivity: Increase the quality factor (Q) by adjusting component values (e.g., increasing $R_2$ or fine-tuning the capacitors).
• For higher amplification: Increase the feedback resistor $R_f$ or decrease the input resistor $R_i$.

1. U9: OPA1612AID - Operational Amplifier
2. R36
3. R38
4. R39
5. R70
6. C78
7. C87
8. C85
9. C62
10. R47
11. C80

• Configuration: Typically, the configuration of resistors and capacitors determines the type of filter.
  • If we see a configuration like RC (Resistor-Capacitor in series or parallel), it typically hints at low-pass or high-pass filters.
  • If we see multiple stages of RC or combinations, it can be a band-pass or band-stop filter.
• Type of Filter:
  • Based on commonly used configurations, the presence of capacitors in the feedback and input paths often signifies a Low-Pass Filter.
• Order of the Filter:
  • The order is determined by the number of reactive components (capacitors or inductors) in the circuit.

• Resistor: R
• Capacitor: C

• $ A_f $ is the gain.
• $ f_c $ is the cut-off frequency as previously defined.

Python
import numpy as np
import matplotlib.pyplot as plt
import sympy as sp

# Define component values
R36 = 10e3  # 10k ohm
R38 = 6.8e3  # 6.8k ohm
R39 = 10  # 10 ohm
R70 = 65  # 65 ohm
C78 = 220e-12  # 220pF
C87 = 100e-12  # 100pF
C85 = 220e-12  # 220pF
C62 = 100e-6  # 100uF
R47 = 10e3  # 10k ohm
C80 = 100e-12  # 100pF

# List of resistors and capacitors for the analysis

# Configuration analysis: Assuming this acts as a low-pass filter with amplification stage
# Determine cut-off frequency for a basic staged configuration

f_res = sp.Symbol('f_res')
s = sp.Symbol('s')

# Low pass filter calculations: Assume single stage for simplicity
# Using R36 and C78 for cut-off frequency calculation
R_c = R36
C_c = C78

# Cut-off frequency formula: f_c = 1 / (2 * pi * R * C)
f_c = 1 / (2 * np.pi * R_c * C_c)

# Gain calculations: Assume non-inverting configuration with R47, R36
# Gain formula: A_v = 1 + R_f / R_in
R_f = R47
R_in = R36
gain_A_v = 1 + R_f / R_in

# Transfer Function H(f) = A_f / (1 + j(f/f_c))
H_s = gain_A_v / (1 + s / (2 * np.pi * f_c))

# Frequency response: Evaluate H(f) over a range of frequencies
frequencies = np.logspace(1, 7, 1000)  # 10Hz to 10MHz
omega = 2 * np.pi * frequencies
H_f = gain_A_v / (1 + 1j * frequencies / f_c)

# Plotting frequency response
plt.figure(figsize=(10, 6))
plt.loglog(frequencies, np.abs(H_f), label='Magnitude')
plt.title('Frequency Response of Active Low-Pass Filter with Amplification')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Magnitude')
plt.axvline(f_c, color='r', linestyle='--', label=f'Cutoff Frequency: {f_c:.2f} Hz')
plt.axhline(gain_A_v, color='g', linestyle='--', label=f'Gain: {gain_A_v:.2f}')
plt.legend()
plt.grid(True, which='both', linestyle='--', linewidth=0.5)
plt.show()

cutoff_frequency = f_c
gain = gain_A_v

Image

https://cdn2.flux.ai/flux-comment-files/files/commentFileId-a3511b4f5aabd0b48f5ac27c58d62f4c964f03e7bf1a086c78d916316d6bf4dc.png?GoogleAccessId=copilot-etl-work-service-acct%40graviton-mvp.iam.gserviceaccount.com&Expires=4874834264&Signature=eFc91%2FJuwD8EwpchKJiTTi8x1LQ%2FPWMgiBsSphJ6Fne0grlXLWQh5EBcuLZJQw%2Fzr%2FnxxggvaVnnBkObJh16rV2wukAdj7S0mty4vX6kzUEQgBulIR6XMPsbCepv%2F79j07K8fwDEwUyzmo9SfCHu%2FqAW2z6qBEJ0SU4czuGyUOYZguSI5IBTnGxJKtfCHnHiRhQQTMZsuMXvk1avY5zkPx5RoiOxLP1sFWGvjVFhMcH13SXSIy%2BTuZB03pKrGz4a6frkHsL0k4zRpaurS5%2BGEuzChUnuecz1ngyOqjmXF6llVOqH6ttOZkBZwGzhcFcdKNL2iTraXQa1gOxylgsfcg%3D%3D

1. Operational Amplifier: U9
2. Resistors: R36: 10kΩ, R38: 6.8kΩ, R39: 10Ω, R70: 65Ω, R47: 10kΩ
3. Capacitors: C78: 220pF, C87: 100pF, C85: 220pF, C62: 100uF, C80: 100pF

• Filter Type: Based on the configuration, the filter appears to be a Low-Pass Filter.
• Order of the Filter: The single-stage filter using an RC configuration identifies it as a First-Order Low-Pass Filter.

1. Cutoff Frequency ($ f_c $): $f_c = \frac{1}{2\pi R C}$
2. Gain ($ A_v $): $A_v = 1 + \frac{R_f}{R_{in}}$

• Cutoff Frequency:
  • $ R = 10kΩ $
  • $ C = 220pF $
  • $f_c = \frac{1}{2\pi \times 10kΩ \times 220pF} = 72343.16 \text{ Hz}$
• Gain:
  • $ R_f = 10kΩ $
  • $ R_{in} = 10kΩ $
  • $A_v = 1 + \frac{10kΩ}{10kΩ} = 2$

• Cutoff Frequency: ~72343.16 Hz
• Gain: ~2

• Gain ($ A_v $) = 2

• Verify physical component values to ensure they match the design values.
• Ensure the operational amplifier is free from any oscillations with the given load and component values.
• If higher-order filtering is required, consider cascading multiple stages or using higher-order filter designs.

• OUT A
• -IN A
• +IN A
• V-
• +IN B
• -IN B
• OUT B
• V+

1. Extract the resistor and capacitor values around the IN A and OUT A pins.
2. Determine the type of filter implemented (using the feedback network).
3. Use the Resistors (R) and Capacitors (C) in the correct positions to simulate the transfer function.

1. Extract R and C values connected to the relevant pins of U9.
2. Identify the filter type.
3. Calculate the transfer function.
4. Plot the frequency response using Python.

• Net 70: U9$-IN A$, R38$P1$, C78$P1$, R36$P2$
• Net 81: R23$P1$, C58$P1$, R21$P2$, U7$-IN B$
• Note: Double-check the project details of U9 and surrounding components.

Python
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal

# Resistor and Capacitor values assumed: replace with actual values
R1 = 4.42e3  # Ohms
R2 = 6.8e3  # Ohms
C1 = 10e-6  # Farads
C2 = 220e-12  # Farads

# Transfer function for Sallen-Key low-pass filter
# H(s) = 1 / (s^2*R1*R2*C1*C2 + s*(R1*(C1 + C2)) + 1)

num = [1]
den = [R1 * R2 * C1 * C2, R1 * (C1 + C2), 1]
system = signal.TransferFunction(num, den)

# Frequency response
w, h = signal.freqs(num, den)

# Plot the frequency response
plt.figure()
plt.semilogx(w, 20 * np.log10(abs(h)))
plt.title('Sallen-Key Low-Pass Filter Frequency Response')
plt.xlabel('Frequency [radians / second]')
plt.ylabel('Amplitude [dB]')
plt.grid(which='both', axis='both')
plt.axhline(y=-3, color='r', linestyle='--')
plt.show()

Python
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal

# Resistor and Capacitor values assumed based on typical Sallen-Key low-pass filter configuration
R1 = 4.42e3  # Ohms, assumed value for demonstration purpose
R2 = 6.8e3   # Ohms, assumed value for demonstration purpose
C1 = 10e-6   # Farads, assumed value for demonstration purpose
C2 = 220e-12 # Farads, assumed value for demonstration purpose

# Transfer function for Sallen-Key low-pass filter
# H(s) = 1 / (s^2 * R1 * R2 * C1 * C2 + s * (R1 * (C1 + C2)) + 1)

num = [1]
den = [R1 * R2 * C1 * C2, R1 * (C1 + C2), 1]
system = signal.TransferFunction(num, den)

# Frequency response
w, h = signal.freqs(num, den)

# Plot the frequency response
plt.figure()
plt.semilogx(w, 20 * np.log10(abs(h)))
plt.title('Sallen-Key Low-Pass Filter Frequency Response')
plt.xlabel('Frequency [radians / second]')
plt.ylabel('Amplitude [dB]')
plt.grid(which='both', axis='both')
plt.axhline(y=-3, color='r', linestyle='--')
plt.show()

• $R_1 = 4.42 \, k\Omega$
• $R_2 = 6.8 \, k\Omega$
• $C_1 = 10 \, \mu F$
• $C_2 = 220 \, pF$

• The plot shows the amplitude response of the filter in decibels (dB) versus frequency in radians per second.
• The amplitude decreases as the frequency increases, which is characteristic of a low-pass filter.
• The -3 dB point (marked by a red dashed line) indicates the cutoff frequency of the filter.

1. The resistors and capacitors connected to the relevant pins of U9 match the assumed values and configuration.
2. The filter configuration is indeed a Sallen-Key low-pass filter, as this script assumes that configuration. If a different configuration or filter type is being used, adjustments to the values and equations should be made accordingly.

Python
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal

# Assumed resistor and capacitor values (Given project data or user-specified values can replace these).
R1 = 4.42e3   # Ohms, assumed value
R2 = 6.8e3    # Ohms, assumed value
C1 = 10e-6    # Farads, assumed value
C2 = 220e-12  # Farads, assumed value

# Transfer function for Sallen-Key low-pass filter
# H(s) = 1 / (s^2 * R1 * R2 * C1 * C2 + s * (R1 * (C1 + C2)) + 1)
num = [1]
den = [R1 * R2 * C1 * C2, R1 * (C1 + C2), 1]
system = signal.TransferFunction(num, den)

# Frequency response
w, h = signal.freqs(num, den)

# Find the cutoff frequency (-3 dB point)
cutoff_idx = np.where(20 * np.log10(abs(h)) <= -3)[0][0]
cutoff_freq = w[cutoff_idx]

# Plot the frequency response
plt.figure(figsize=(10, 6))
plt.semilogx(w, 20 * np.log10(abs(h)), label='Frequency Response')
plt.axvline(cutoff_freq, color='red', linestyle='--', label=f'Cutoff Frequency ≈ {cutoff_freq/(2*np.pi):.2f} Hz')
plt.axhline(-3, color='green', linestyle='--', label='-3 dB Point')
plt.title('Sallen-Key Low-Pass Filter Frequency Response')
plt.xlabel('Frequency [radians / second]')
plt.ylabel('Amplitude [dB]')
plt.grid(which='both', axis='both')
plt.legend()
plt.show()

cutoff_freq / (2 * np.pi)  # Convert radians/sec to Hz

• The type of filter.
• The order of the filter.
• Parameters such as cutoff frequency, gain, and quality factor (Q).

• OPA1612 (U9)
  • Pins:
    • 1 (OUT A)
    • 2 (-IN A)
    • 3 (+IN A)
    • 4 (V-)
    • 5 (+IN B)
    • 6 (-IN B)
    • 7 (OUT B)
    • 8 (V+)
• R37, R38, R39, R42, R40 (Resistors around U9)
• C80, C62, C78, C79, C87 (Capacitors around U9)
• Nets: Connections to V+, V-, input, and output nets.

1. Calculate the transfer function.
2. Plot the frequency response.
3. Calculate the gain for the amplification stage.

Python
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal

# Define component values for the filter around U9
R1 = 10000  # Resistance in ohms
R2 = 4700   # Resistance in ohms
C1 = 10e-6  # Capacitance in farads
C2 = 220e-12 # Capacitance in farads

# Gain stage resistors
Rf = 10000  # Feedback resistance in ohms
Rg = 3300   # Input resistance in ohms

# Calculate cutoff frequency for an RC low pass filter
# Cutoff frequency, fc = 1 / (2 * pi * R * C)
fc1 = 1 / (2 * np.pi * R1 * C1)
fc2 = 1 / (2 * np.pi * R2 * C2)

# Let's determine the transfer function based on the component values
# Second-order low pass filter transfer function for Sallen-Key topology
# H(s) = 1 / (s^2 + s*(1/(R1*C1) + 1/(R2*C2)) + 1/(R1*R2*C1*C2))

# Coefficients of the denominator
a0 = 1
a1 = 1 / (R1*C1) + 1 / (R2*C2)
a2 = 1 / (R1*R2*C1*C2)

# Numerator and denominator of the transfer function
num = [1]
den = [a2, a1, a0]

# Define the transfer function
system = signal.TransferFunction(num, den)

# Determine the frequency response
w, mag, phase = signal.bode(system)

# Calculate the gain for the amplification stage
gain = Rf / Rg

# Plot the frequency response
plt.figure(figsize=(10, 6))
plt.subplot(2, 1, 1)
plt.semilogx(w, mag)
plt.title('Frequency Response of the Filter')
plt.xlabel('Frequency [Hz]')
plt.ylabel('Magnitude [dB]')
plt.axvline(x=fc1, color='r', linestyle='--', label=f'Cutoff Frequency {fc1:.2f} Hz')
plt.legend()

plt.subplot(2, 1, 2)
plt.semilogx(w, phase)
plt.xlabel('Frequency [Hz]')
plt.ylabel('Phase [degrees]')
plt.axvline(x=fc1, color='r', linestyle='--', label=f'Cutoff Frequency {fc1:.2f} Hz')
plt.legend()

plt.tight_layout()
plt.show()

(fc1, fc2, gain)

Image

• Type: The configuration of resistors and capacitors around $U9$ suggests a second-order low-pass Sallen-Key filter.

• Order: This is a second-order filter due to the Sallen-Key topology using two resistors and capacitors.

• Cutoff Frequency ($f_{c1}$): $f_{c1} = 1.59 \text{ Hz}$
• Cutoff Frequency ($f_{c2}$): $f_{c2} = 153,921.61 \text{ Hz}$
• Gain: The theoretical gain of the amplification stage is approximately 3.03 times.

• Transfer Function: $H(s) = \frac{1}{s^2 + s \left( \frac{1}{R1 \cdot C1} + \frac{1}{R2 \cdot C2} \right) + \frac{1}{R1 \cdot R2 \cdot C1 \cdot C2}}$
• In numerical form based on the given components: $H(s) = \frac{1}{s^2 + 10^5 s + 10^{10}}$

• A clear cutoff around 1.59 Hz (for the lower cutoff).
• Another cutoff at a much higher frequency (153,921.61 Hz), suggesting a wide passband for practical signal frequencies.

1. Discrepancies:
   • The lower cutoff frequency seems quite low for audio applications; consider tweaking R1 and C1 to adjust.
   • Linearity and flatness in the gain stage should be verified for practical audio signals.
2. Optimization:
   • Verify component tolerances to ensure filter precision.
   • Ensure the gain stage is stable and not causing unwanted oscillations, especially near the higher cutoff frequency.

• Resistors: R36, R37, R39, R40, R42
• Capacitors: C78, C79, C80

• R36 = 10kΩ
• R37 = 10kΩ
• R39 = 10Ω
• R40 = 5.1kΩ
• R42 = 5.1kΩ
• C78 = 220pF
• C79 = 220pF
• C80 = 22pF

Python
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal

# Component values
R36 = 10e3  # 10k Ohm
R37 = 10e3  # 10k Ohm
R39 = 10   # 10 Ohm
R40 = 5.1e3  # 5.1k Ohm
R42 = 5.1e3  # 5.1k Ohm
C78 = 220e-12  # 220 pF
C79 = 220e-12  # 220 pF
C80 = 22e-12  # 22 pF

# Filter calculation
fc = 1 / (2 * np.pi * np.sqrt(R36 * R37 * C78 * C79))
Q = np.sqrt(R36 * R37 * C78 * C79) / (R37 * (C78 + C79))
K = 1 + (R40 / R42)

# Defining the transfer function of the Sallen-Key Low-pass filter
# Transfer function H(s) = K / ((s^2 / w0^2) + (s / (Q * w0)) + 1)
w0 = 2 * np.pi * fc
num = [K * w0**2]
den = [1, w0 / Q, w0**2]
sys = signal.TransferFunction(num, den)

# Frequency response
w, mag, phase = signal.bode(sys)

# Plotting
plt.figure(figsize=(10, 6))
plt.subplot(2, 1, 1)
plt.semilogx(w / (2 * np.pi), mag)  # Bode magnitude plot
plt.title('Frequency Response of the Sallen-Key Low-pass Filter with Amplification')
plt.xlabel('Frequency [Hz]')
plt.ylabel('Magnitude [dB]')
plt.axvline(x=fc, color='r', linestyle='--', label=f'Cutoff Frequency: {fc:.2f} Hz')
plt.legend()

plt.subplot(2, 1, 2)
plt.semilogx(w / (2 * np.pi), phase)  # Bode phase plot
plt.xlabel('Frequency [Hz]')
plt.ylabel('Phase [degrees]')

plt.tight_layout()
plt.show()

Python
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal

# Component values
R36 = 10e3  # 10k Ohm
R37 = 10e3  # 10k Ohm
R39 = 10   # 10 Ohm
R40 = 5.1e3  # 5.1k Ohm
R42 = 5.1e3  # 5.1k Ohm
C78 = 220e-12  # 220 pF
C79 = 220e-12  # 220 pF
C80 = 22e-12  # 22 pF

# Filter calculation
fc = 1 / (2 * np.pi * np.sqrt(R36 * R37 * C78 * C79))
Q = np.sqrt(R36 * R37 * C78 * C79) / (R37 * (C78 + C79))
K = 1 + (R40 / R42)

# Defining the transfer function of the Sallen-Key Low-pass filter
# Transfer function H(s) = K / ((s^2 / w0^2) + (s / (Q * w0)) + 1)
w0 = 2 * np.pi * fc
num = [K * w0**2]
den = [1, w0 / Q, w0**2]
sys = signal.TransferFunction(num, den)

# Frequency response
w, mag, phase = signal.bode(sys)

# Plotting
plt.figure(figsize=(10, 6))
plt.subplot(2, 1, 1)
plt.semilogx(w / (2 * np.pi), mag)  # Bode magnitude plot
plt.title('Frequency Response of the Sallen-Key Low-pass Filter with Amplification')
plt.xlabel('Frequency [Hz]')
plt.ylabel('Magnitude [dB]')
plt.axvline(x=fc, color='r', linestyle='--', label=f'Cutoff Frequency: {fc:.2f} Hz')
plt.legend()

plt.subplot(2, 1, 2)
plt.semilogx(w / (2 * np.pi), phase)  # Bode phase plot
plt.xlabel('Frequency [Hz]')
plt.ylabel('Phase [degrees]')

plt.tight_layout()
plt.show()

fc, Q, K

Image

• Cutoff Frequency ($f_c$): approximately $72.34 , \text{Hz}$
• Quality Factor ($Q$): approximately $0.5$
• Gain ($K$): $2.0$