1. Define the frequency range for the bandpass filter.
2. Calculate the component values based on the desired cutoff frequencies.
3. Simulate the filter and plot the frequency response.

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

# Specifications
f_lower = 300  # Lower cutoff frequency in Hz
f_upper = 3400 # Upper cutoff frequency in Hz
f_center = np.sqrt(f_lower * f_upper)  # Center frequency in Hz
Q = f_center / (f_upper - f_lower)  # Quality factor

# Sampling rate for the simulation
fs = 48000

# Design the bandpass filter
b, a = signal.iirpeak(f_center, Q, fs=fs)

# Frequency response
w, h = signal.freqz(b, a, worN=8000, fs=fs)

# Plot the frequency response
plt.figure()
plt.plot(w, 20 * np.log10(abs(h)))
plt.title('Second Order Active Bandpass Filter Frequency Response')
plt.xlabel('Frequency [Hz]')
plt.ylabel('Amplitude [dB]')
plt.grid()
plt.axvline(f_center, color='r', linestyle='--', label='Center Frequency')
plt.axvline(f_lower, color='g', linestyle='--', label='Lower Cutoff Frequency')
plt.axvline(f_upper, color='b', linestyle='--', label='Upper Cutoff Frequency')
plt.legend()
plt.show()

Diagram

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

# Specifications
f_lower = 300  # Lower cutoff frequency in Hz
f_upper = 3400 # Upper cutoff frequency in Hz
f_center = np.sqrt(f_lower * f_upper)  # Center frequency in Hz
Q = f_center / (f_upper - f_lower)  # Quality factor

# Sampling rate for the simulation
fs = 48000

# Design the bandpass filter
b, a = signal.iirpeak(f_center, Q, fs=fs)

# Frequency response
w, h = signal.freqz(b, a, worN=8000, fs=fs)

# Plot the frequency response
plt.figure()
plt.plot(w, 20 * np.log10(abs(h)))
plt.title('Second Order Active Bandpass Filter Frequency Response')
plt.xlabel('Frequency [Hz]')
plt.ylabel('Amplitude [dB]')
plt.grid()
plt.axvline(f_center, color='r', linestyle='--', label='Center Frequency')
plt.axvline(f_lower, color='g', linestyle='--', label='Lower Cutoff Frequency')
plt.axvline(f_upper, color='b', linestyle='--', label='Upper Cutoff Frequency')
plt.legend()
plt.show()

Diagram

1. Impedance Matching: Assuming an input impedance of the amplifier higher than the impedance of MK3, there's no need for a matching network.
2. Power Supply Decoupling: Typically, a 0.1 µF capacitor placed close to the power pins of the op-amp.
3. Gain Setting: Gain for the non-inverting amplifier configuration is given by $ \text{Gain} = 1 + \frac{R2}{R1} = 10 $ implying $ R2 = 9 \times R1 $.
4. DC Filtering: Applying a high-pass filter (cut-off, $ f_c $ = 20 Hz).

• For the gain setting:
  $$R2 = 9 \times R1$$
  We can choose common resistor values, let's start with $ R1 = 10 \text{k}\Omega $.
  $$R2 = 9 \times 10 \text{k}\Omega = 90 \text{k}\Omega$$
• For the DC filter, with a cut-off frequency of 20 Hz, the high-pass filter capacitor (C2) value (assuming $ R_{in} $ is the input resistance):
  $$f_c = \frac{1}{2 \pi R_{in} C2}$$
  Assuming $ R_{in} = 10 \text{k}\Omega $, we can solve for (C2):
  $$C2 = \frac{1}{2 \pi \times 10 \text{k}\Omega \times 20 \text{Hz}}$$
  Now, let's calculate these values.

Python
import math

# Constants
R1_value = 10e3  # 10 kOhms
gain = 10
fc = 20  # cut-off frequency in Hz
Rin = 10e3  # 10 kOhms

# Calculate R2 based on the gain formula
R2_value = (gain - 1) * R1_value  # 9 * 10k

# Calculate the capacitor for DC filtering
C2_value = 1 / (2 * math.pi * Rin * fc)  # From cutoff frequency formula

# Capacitor for decoupling
C_decouple_value = 0.1e-6  # Typical value is 0.1 µF

# Format values
components = [
    {"component": "R1", "value": f"{R1_value/1e3:.2f}kΩ", "package": "SMD_0603_1608Metric", "purpose": "Gain setting"},
    {"component": "R2", "value": f"{R2_value/1e3:.2f}kΩ", "package": "SMD_0603_1608Metric", "purpose": "Gain setting"},
    {"component": "C1", "value": f"{C2_value*1e6:.3f}µF", "package": "SMD_0603_1608Metric", "purpose": "DC filtering"},
    {"component": "C2", "value": "0.1µF", "package": "SMD_0603_1608Metric", "purpose": "Power supply decoupling"}
]

components

• R1 and R2: These resistors set the gain to 10 for the OPA134UA op-amp.
• C1: This capacitor provides DC filtering with a cut-off frequency of 20 Hz.
• C2: This 0.1 µF capacitor is used for power supply decoupling to provide stability for the op-amp.

1. A high-pass filter to allow frequencies above 300 Hz.
2. A low-pass filter to allow frequencies below 3400 Hz.

1. High-Pass Filter Design:
   • Cut-off frequency $f_c$ = 300 Hz
   • Capacitor $C$ and resistor $R$ values will be calculated.
2. Low-Pass Filter Design:
   • Cut-off frequency $f_c$ = 3400 Hz
   • Capacitor $C$ and resistor $R$ values will be calculated.

Python
import numpy as np

# Constants
f_high = 300  # High-pass frequency in Hz
f_low = 3400  # Low-pass frequency in Hz
R = 10000  # Resistance in ohms, standard value for calculation

# Butterworth constants for a second-order filter
sqrt_2 = np.sqrt(2)

# Angular frequencies
omega_high = 2 * np.pi * f_high
omega_low = 2 * np.pi * f_low

# Calculate the capacitance for the high-pass section
C_high = 1 / (omega_high * R)

# Calculate the capacitance for the low-pass section
C_low = 1 / (omega_low * R)

(C_high, C_low)

Python
import numpy as np

# Constants
f_high = 300  # High-pass frequency in Hz
f_low = 3400  # Low-pass frequency in Hz
R = 10000  # Resistance in ohms, standard value for calculation

# Butterworth constants for a second-order filter
sqrt_2 = np.sqrt(2)

# Angular frequencies
omega_high = 2 * np.pi * f_high
omega_low = 2 * np.pi * f_low

# Calculate the capacitance for the high-pass section
C_high = 1 / (omega_high * R)

# Calculate the capacitance for the low-pass section
C_low = 1 / (omega_low * R)

C_high, C_low

• High-pass filter capacitor (C_high): $53.05 , \text{nF}$
• Low-pass filter capacitor (C_low): $4.68 , \text{nF}$

1. High-Pass Filter:
   • Connect the input signal to $R1$:1.
   • Connect $R1$:2 to $C1$:1.
   • Connect $C1$:2 to GND.
2. Low-Pass Filter:
   • Connect the output of the high-pass filter to $R2$:1.
   • Connect $R2$:2 to $C2$:1.
   • Connect $C2$:2 to GND.

• High-Pass Filter
  • Connect the input signal to $R1$:1.
  • Connect $R1$:2 to $C1$:1.
  • Connect $C1$:2 to GND.
• Low-Pass Filter
  • Connect $R2$:1 to $R1$:2 (Output of High-Pass Filter).
  • Connect $R2$:2 to $C2$:1.
  • Connect $C2$:2 to GND.

• Principle: ANC works by using destructive interference to cancel out unwanted noise. This involves capturing the ambient noise, inverting its phase, and then adding it back to the original sound, effectively cancelling out the noise.
• Components Involved: Microphones, signal processing unit (typically a DSP or microcontroller), and speakers/earphones.

1. Microphones
   • Type: MEMS microphones are commonly used due to their small size, low power consumption, and sensitivity.
   • Example: Knowles SPH0645LM4H, InvenSense ICS-40720
2. Digital Signal Processor (DSP) or Microcontroller
   • Function: Handles the signal processing algorithms to invert and mix the audio signals.
   • Example DSPs:
     • Texas Instruments TLV320AIC3204
     • Analog Devices ADAU1701
   • Example Microcontrollers:
     • Microchip PIC32MX
     • ESP32
3. Speakers/Earphones
   • Type: Miniature speakers or balanced armature drivers suitable for hearing aids.
   • Example: Balanced Armature Driver
4. Power Supply
   • Type: Small-sized rechargeable batteries are common in hearing aids.
   • Example: Li-ion batteries
5. Passive Components
   • Resistors, Capacitors, Inductors: Used for filtering and biasing circuits.

1. Noise Cancelling Algorithms
   • Familiarize yourself with algorithms like LMS (Least Mean Squares) and adaptive filtering techniques.
   • Study signal processing basics, including Fourier transforms and filtering techniques.
2. Acoustics and Psychoacoustics
   • Understanding how sound waves interact and how the human ear perceives different frequencies is crucial.
3. Component Selection and Circuit Design
   • Choosing low-noise components to ensure high efficiency.
   • Design considerations for low power consumption, as hearing aids need long battery life.
4. PCB Layout and Size Constraints
   • Given the small form factor of hearing aids, your PCB needs to be compact.
5. Signal Integrity and EMI/EMC
   • Ensuring that your circuit design handles high-frequency noise and interference appropriately.

1. Microphone Placement and Sensitivity:
   • Calculate the optimal placement for the microphones to accurately capture ambient noise.
2. Filter Design:
   • Design low-pass and band-pass filters to isolate the noise frequency range.
   $H(s) = \frac{s + \omega_z}{s + \omega_p}$
   where $\omega_z$ is the zero frequency and $\omega_p$ is the pole frequency.
3. Power Consumption:
   • Calculate the total power consumption, considering the components' power requirements.
4. Feedback Loop Stability:
   • Ensure the feedback system is stable by analyzing the loop gain and phase margins.

1. Define the Specifications:
   • Establish noise reduction levels, frequency response, battery life, and size constraints.
2. Select Components:
   • Choose the appropriate microphones, DSP/microcontroller, and speakers.
3. Design the Schematic:
   • Create the circuit schematic in Flux, starting with the microphones, DSP, and output stages.
4. Develop and Test the Algorithms:
   • Implement noise-cancelling algorithms and test them in a simulation environment before hardware implementation.
5. PCB Design:
   • Lay out the PCB considering signal paths, component placement, and size constraints.
6. Prototyping and Testing:
   • Assemble a prototype and perform thorough testing to fine-tune the system.

• Microphones:
  • Connect Mic1:OUT to DSP:IN1.
  • Connect Mic2:OUT to DSP:IN2.
• DSP and Speaker:
  • Connect DSP:OUT1 to Speaker:IN.

• Resistor: R1

Diagram

• Input Stage:
  • Microphone 1 and Microphone 2: Capture ambient noise and sound from the surroundings.
• Amplification and Filtering:
  • Pre-Amplifiers: Amplify the microphone signals for processing.
  • Low-Pass Filter: Filters out high-frequency noises and allows the noise signal spectrum pass through.
• Signal Processing:
  • Digital Signal Processor (DSP): Processes the filtered signals to generate the counteracting noise signal.
  • Microcontroller: Coordinates the ANC algorithm implementation and communication with other components.
• Output Stage:
  • Power Amplifier: Amplifies the processed signal to drive the speaker.
  • Speaker: Outputs the noise-cancelled sound.

Diagram

• Microphone: Captures the ambient noise.
• DC Biasing Circuit: Provides the necessary DC biasing for the microphone signal, making it suitable for amplification.
• Pre-Amplifier: Amplifies the microphone signal to a level suitable for processing.
• Low-Pass Filter: Filters out high-frequency components, allowing only the low-frequency noise spectrum to pass through for further processing.

• Biasing Circuit: Typically consists of a resistor and capacitor to provide proper DC biasing.
• Pre-Amplifier: Usually an operational amplifier (e.g., OPA4342) or a transistor-based amplifier.

• RC Filter Components: A combination of resistor and capacitor to set the cutoff frequency.

• Microphone_Out to Biasing Circuit_In.
• Biasing Circuit_Out to Pre-Amplifier_In.
• Pre-Amplifier_Out to Low-Pass Filter_In.

• Microphone: Ensure the microphone is well-matched for acoustic performance and sensitivity.
• Pre-Amplifier: Choose op-amps with low noise and high precision to ensure high-quality audio signal amplification.
• DC Bias and Coupling Components: These passive components ensure the microphone operates correctly and the amplified signal is clean.
• Low-Pass Filter: The resistor and capacitor values determine the cutoff frequency. For speech frequencies, a cutoff around 3kHz is typical.
• PCB Design: Layout considerations are crucial for minimizing noise pickup and ensuring signal integrity.

• To filter out high-frequency components from the analog signal before it is sampled by an ADC (Analog-to-Digital Converter).

• Typically a low-pass filter (LPF) is used for anti-aliasing.

• Use a second-order (or higher) Butterworth filter for a flat passband.

• Choose $R = 10k\Omega$
• Then, $C = \frac{1}{2 \pi R f_c} = \frac{1}{2 \pi \cdot 10k \cdot 5k} \approx 1nF$

Diagram

• Operational Amplifier (Op-Amp): To execute the active filter stage.
• RC Network: To establish the filter’s cutoff frequency.

• Cutoff Frequency Adjustment: Ensure your cutoff frequency is slightly below half the ADC sampling rate to effectively filter out unwanted high frequencies.
• Filter Order: Higher-order filters provide better attenuation outside the passband but at the cost of increased design complexity.

Diagram

1. Input Stage:
   • Microphone 1: Captures ambient sound.
   • Microphone 2: Provides an additional reference signal or redundant capture.
2. Amplification and Filtering:
   • Bias Circuit 1 and 2: Provide necessary DC biasing to the microphone signals.
   • Pre-Amplifier 1 and 2: Amplify the biased microphone signals.
   • Low-Pass Filter 1 and 2: Filter out high-frequency noise components.
   • Anti-Aliasing Filter 1 and 2: Prior to ADC conversion, ensure higher-frequency noise does not alias.
3. Signal Processing:
   • DSP: Processes the filtered signals to generate an anti-noise signal.
   • Microcontroller: Manages the overall control, including interfacing with the DSP.
4. Output Stage:
   • Power Amplifier: Amplifies the DSP's output signal to drive the speaker.
   • Speaker: Outputs the noise-cancelled sound to the user.

• Connect A:OUT to C:IN
• Connect B:OUT to D:IN

• Connect C:OUT to E:IN
• Connect D:OUT to F:IN

• Connect E:OUT to G:IN
• Connect F:OUT to H:IN

• Connect G:OUT to I:IN
• Connect H:OUT to J:IN

• Connect I:OUT to K:ADC_IN1
• Connect J:OUT to K:ADC_IN2
• Connect N:CONTROL to K:CTRL

• Connect K:OUT to L:IN
• Connect L:OUT to M:IN

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

# Define the specifications for Butterworth bandpass filter
fs = 10000  # Sampling frequency 10kHz
lowcut = 300  # Lower cutoff frequency
highcut = 3400  # Upper cutoff frequency

# Calculate the filter coefficients
order = 2  # Second order
nyquist = 0.5 * fs
low = lowcut / nyquist
high = highcut / nyquist

b, a = signal.butter(order, [low, high], btype='band')

# Frequency response
w, h = signal.freqz(b, a)

# Plot the frequency response
plt.figure(figsize=(10, 6))
plt.plot((fs * 0.5 / np.pi) * w, abs(h), 'b')
plt.title('Second Order Butterworth Bandpass Filter Frequency Response')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Gain')
plt.grid()
plt.show()

# Coefficients for block diagram representation
b, a

Diagram

• Numerator Coefficients (b): $[0.41271939, 0, -0.82543878, 0, 0.41271939]$
• Denominator Coefficients (a): $[1, -1.09926836, -0.06355741, 0.02180571, 0.20667199]$

• The exact resistor and capacitor values depend on the desired filter tuning.
• U1 may be replaced with a different op-amp depending on specific requirements.

• $ f_0 $ is the center frequency $ \sqrt{f_L \cdot f_H} $
• $ Q $ is the Quality factor, given by $ \sqrt{\frac{f_H - f_L}{f_H + f_L}} $
• $ R1 $ and $ R2 $ are resistors
• $ C1 $ and $ C2 $ are capacitors

Python
import numpy as np

# Given values
f_L = 300
f_H = 3400
f_0 = np.sqrt(f_L * f_H)
Q = np.sqrt((f_H - f_L) / (f_H + f_L))

C1 = 10e-9  # 10 nF
C2 = 10e-9  # 10 nF

# Calculating R1 and R2
R1 = Q / (2 * np.pi * f_0 * C1)
R2 = 1 / (2 * np.pi * f_0 * C2 * Q)

(f_0, Q, R1, R2)

Python
# Calculation Script for Component Sizes

# Given values
f_L = 300  # Lower cutoff frequency in Hz
f_H = 3400  # Upper cutoff frequency in Hz
f_0 = np.sqrt(f_L * f_H)  # Center frequency
Q = np.sqrt((f_H - f_L) / (f_H + f_L))  # Quality factor

C1 = 10e-9  # 10 nF in Farads
C2 = 10e-9  # 10 nF in Farads

# Calculate R1 and R2
R1 = Q / (2 * np.pi * f_0 * C1)
R2 = 1 / (2 * np.pi * f_0 * C2 * Q)

f_0, Q, R1, R2

• Center Frequency ($ f_0 $): $ 1009.95 , \text{Hz} $
• Quality Factor ($ Q $): $ 0.915 $

• Capacitors (Assumed):
  • $ C1 = 10 , \text{nF} $
  • $ C2 = 10 , \text{nF} $
• Resistors (Calculated):
  • $ R1 = 14.42 , \text{k}\Omega $
  • $ R2 = 17.22 , \text{k}\Omega $

Diagram