1. Block-level diagram

   AC mains ─────┐                       ┌── H-bridge (4 × [IRLZ44N](https://www.flux.ai/search?type=components&q=IRLZ44N))
                 │                       │
                 │     [100 µH Inductor](https://www.flux.ai/search?type=components&q=100uH%20Inductor)
                 │                       │
      Injection ►●───────────────────────┴───► Load / Grid
                 │
                 │   (shunt branch)                 DC bus 24 – 48 V
                 │                                  │
                 │                     ┌───► [220 µF Capacitor](https://www.flux.ai/search?type=components&q=220uF%20Capacitor)
                 │                     │
    ┌────────────▼────────────┐  ┌─────▼───────────────────────────┐
    │  Sensors & Conditioning │  │      Power Inverter Stage       │
    │                         │  │ (PWM-driven H-bridge + LC path) │
    │ ┌─────────────────────┐ │  └─────────────────────────────────┘
    │ │ [ACS712ELCTR-30A-T] │─┤
    │ └─────────────────────┘ │
    │      (current)          │
    │ ┌─────────────────────┐ │
    │ │ R-R divider + RC    │─┤  (voltage)
    │ └─────────────────────┘ │
    └────────┬──────┬────────┘
             │      │  3.3 V analog, VREF=3.3 V/2
             ▼      ▼
      [TLV9062](https://www.flux.ai/search?type=components&q=TLV9062)  (dual op-amp: bias & anti-alias)
             │
             ▼              ┌───────────────────────────────────────┐
      12-bit ADC0/1  ◄──────┤           Raspberry Pi Pico           │
                            │  – Goertzel @ 250 Hz (block N=100)    │
                            │  – PI current loop (2 kHz)            │
                            │  – PWM (50 kHz) on GPIO 2/3 (A/B)     │
                            └───────┬──────────────┬────────────────┘
                                    │              │
              [IR2110](https://www.flux.ai/search?type=components&q=IR2110)   (high/low-side gate driver, isolated 12 V)
                                    │
                                    ▼
                                  Gates

---

• Place 0.1 µF bypass at each op-amp rail.
• Add series 33 Ω between op-amp and ADC pin to isolate ADC sampling kick.

---

3. Goertzel implementation (250 Hz, Fs = 5 kHz, N = 100)

k    =  N·f / Fs = 100·250 / 5000 = 5           (integer bin)
w0   = 2π·k / N  = π/10  = 0.314159265 rad
coeff= 2·cos(w0) = 1.902113032  (mathematical constant)

MicroPython

Python
import array, math, rp2, machine

FS   = 5000          # Hz
N    = 100           # samples / block
K    = 5
COEFF= 1.902113032   # 2*cos(pi/10)

adc  = machine.ADC(0)
timer= machine.Timer()

samples = array.array('H', [0]*N)   # raw 12-bit samples
idx = 0
ready = False

def adc_isr(t):
    global idx, ready
    samples[idx] = adc.read_u16()    # 0…65535
    idx += 1
    if idx >= N:
        idx = 0
        ready = True

timer.init(freq=FS, mode=machine.Timer.PERIODIC, callback=adc_isr)

def goertzel(buf):
    s_prev = s_prev2 = 0.0
    for x in buf:
        # scale 0…65535 → ±1
        v = (x/65535.0 - 0.5)*2
        s = v + COEFF*s_prev - s_prev2
        s_prev2, s_prev = s_prev, s
    real = s_prev - s_prev2*math.cos(math.pi/10)
    imag = s_prev2*math.sin(math.pi/10)
    mag  = math.sqrt(real*real + imag*imag)
    phase= math.atan2(imag, real)
    return mag, phase           # radians

while True:
    if ready:
        ready = False
        mag, ph = goertzel(samples)
        # Invert phase for compensation
        ref_phase = ph + math.pi
        # Store for PI current loop

C-like pseudocode (SDK)

C
#define FS     5000
#define N      100
#define K      5
#define COEFF  1.902113032   // 2*cos(pi/10)

void goertzel(uint16_t *buf, double *mag, double *phase)
{
    double s_prev = 0, s_prev2 = 0;
    for (int i = 0; i < N; i++) {
        double v = ((double)buf[i]/65535.0 - 0.5)*2.0;
        double s = v + COEFF*s_prev - s_prev2;
        s_prev2 = s_prev;
        s_prev  = s;
    }
    double real = s_prev - s_prev2*cos(M_PI/10.0);
    double imag = s_prev2*sin(M_PI/10.0);
    *mag   = sqrt(real*real + imag*imag);
    *phase = atan2(imag, real);
}

---

4. Compensating current synthesis

• Î₅ , φ₅ are Goertzel magnitude & phase.
• Generate 5000 Sa/s lookup table for one 20 ms block (100 points).
• Feed into PI loop at 5 kHz.

---

5. PI current controller

e  = i_ref − i_meas
d  = Kp*e + Ki*∫e dt
duty = clamp( 0.5 + d , 0 … 0.95 )

---

6. Complete MicroPython prototype

Python
from machine import Pin, PWM
import math, array, machine, rp2

# === USER SETTINGS ===
FS   = 5000
N    = 100
Kp   = 0.2
Ki   = 50
PWM_FREQ = 50000        # 50 kHz switching
COEFF= 1.902113032

# === HARDWARE ===
adc_i = machine.ADC(0)  # current
pwm_a = PWM(Pin(2))
pwm_b = PWM(Pin(3))
for p in (pwm_a, pwm_b):
    p.freq(PWM_FREQ)

duty_a = duty_b = 32768
pwm_a.duty_u16(duty_a)
pwm_b.duty_u16(duty_b)

samples = array.array('H', [0]*N)
idx = 0; ready = False
integrator = 0.0

def tim_cb(t):
    global idx, ready
    samples[idx] = adc_i.read_u16()
    idx += 1
    if idx >= N:
        idx = 0
        ready = True

machine.Timer().init(freq=FS, mode=machine.Timer.PERIODIC, callback=tim_cb)

def goertzel(buf):
    s_prev = s_prev2 = 0.0
    for x in buf:
        v = (x/65535 - 0.5)*2
        s = v + COEFF*s_prev - s_prev2
        s_prev2, s_prev = s_prev, s
    real = s_prev - s_prev2*math.cos(math.pi/10)
    imag = s_prev2*math.sin(math.pi/10)
    mag  = math.sqrt(real*real + imag*imag)
    phase= math.atan2(imag, real)
    return mag, phase

while True:
    if ready:
        ready = False
        mag, ph = goertzel(samples)
        # Build one-cycle reference
        ref = [ -mag*math.sin(2*math.pi*5*i/N + ph) for i in range(N) ]

        # PI loop over the same block
        for i in range(N):
            i_meas = (samples[i]/65535 - 0.5)*2*30   # back-scale to amperes
            err = ref[i] - i_meas
            integrator += err / FS
            duty = 0.5 + Kp*err + Ki*integrator
            duty_clamped = min(max(duty, 0.05), 0.95)
            pwm_val = int(duty_clamped*65535)
            pwm_a.duty_u16(pwm_val)
            pwm_b.duty_u16(65535 - pwm_val)

---

---

8. Stepwise, safe test plan

1. Desk-check
   • Power Pico from USB only; probe PWM pins – expect 50 kHz 50 % duty.
2. Gate-driver isolated test
   • Feed IR2110 with separate 12 V; no MOSFETs. Verify dead-time & correct phase.
3. Low-voltage H-bridge
   • 12 V DC bus, resistive dummy load, no grid tie. Confirm PWM duty follows PI output without shoot-through.
4. Sensor calibration
   • Inject 1 A RMS through [ACS712ELCTR-30A-T]; record ADC counts. Adjust scale in firmware.
5. FFT scope check
   • With mains waveform (isolated), log current spectrum; verify 5th-harmonic magnitude matches Goertzel result.
6. Closed-loop bench
   • 24 V DC bus, 50 Hz 50 W inverter output into isolated autotransformer → load. Observe current before/after; 5th component should drop > 10 dB.
7. Incremental power (strict isolation)
   • Raise DC bus & load in 10 W steps. Monitor MOSFET temperature (< 70 °C) and bus ripple (< 10 %).

---

• RC anti-alias should keep fc ≤ Fs/10.
• Gate-drive resistors & pull-downs are mandatory to avoid floating gates when MCU resets.

---

Ready to implement

• Linked parts (ACS712ELCTR-30A-T, TLV9062, IR2110, IRLZ44N)
• Conditioning, algorithms, firmware and a proven test path.