How to build DIY Arduino-controlled synchronous buck DC-DC converter

Here I wanted to share Arduino-controlled synchronous buck DC-DC converter design that steps down a 12V input to a regulated lower output voltage (such as 5V) using a 50 kHz high-frequency PWM signal generated by the ATmega328P to drive an IR2104 high-and-low side MOSFET driver and a synchronous half-bridge power stage (IRLB8721, IRLB8721).

I had tested a buck converter designed with Arduino as PID controller in my previous blog post How to design Arduino buck converter with feedback. That buck converter had several short comings and so here is an improved version of the DIY Arduino Buck Converter.

Arduino-controlled synchronous buck DC-DC converter Circuit Diagram:

Features

Microcontroller-Based Digital Control: Uses an Arduino Uno running a 1 kHz closed-loop PID control algorithm with input-voltage feedforward. It uses Fast PWM mode for PWM switching.

Synchronous Rectification: Employs dual N-channel MOSFETs (IRLB8721, IRLB8721) and an IR2104 driver to improve efficiency compared to standard diode-freewheeling buck converters.

Flexible Setpoint Control: Output voltage can be adjusted dynamically via a potentiometer (RV1) on analog input A0 or by entering a target voltage directly through the serial monitor.

Protective Features: Includes software current limiting with foldback, under-voltage lockout, and auto-retry (hiccup) protection modes.

High-Frequency PWM: Utilizes Timer1 configured for 50 kHz fast PWM on pin 9 (OC1A) with a 320-step resolution.

Advantages

High Efficiency: Synchronous rectification drastically reduces conduction and switching losses during freewheeling periods.

Precise Regulation: Feedback loop via voltage divider R3/R4 on A1 ensures steady output voltage under varying load conditions.

Cost-Effective & Adaptable: Combines open-source hardware flexibility with robust power management components ideal for prototyping and educational use.

Program Code

/*
 * SYNCHRONOUS BUCK CONTROLLER v2  -  Arduino UNO / Nano (ATmega328P)
 *
 * Power stage : IR2104 half-bridge driver + 2 N-MOSFETs (synchronous buck)
 * PWM         : Timer1 fast PWM, 50 kHz, 320 steps, on pin 9 (OC1A)
 * Control     : 1 kHz timed loop, input-voltage feedforward + I-dominant PI
 * Protection  : software current limit (foldback), hardware fast trip on pin 2,
 *               input under-voltage lockout, auto-retry (hiccup) after a trip
 * Setpoint    : pot on A0, or type a voltage in the serial monitor
 *               (e.g. "5" or "3.3"); type "p" to go back to the pot
 *
 * FIRST SIMULATION: the three USE_* flags below are false, so A2, A3 and D2
 * can stay unconnected. Set each to true once you have wired that part.
 *
 * Pin map
 *   D9  -> IR2104 IN        D8 -> IR2104 SD (polarity set by SD_ENABLE_HIGH)
 *   D2  <- comparator out   (HIGH = over-current, trips instantly)
 *   A0  pot   A1 output-voltage divider   A2 current-sense amp   A3 input divider
 */

#include <Arduino.h>

// ---------------- Pins ----------------
const uint8_t PIN_PWM = 9;
const uint8_t PIN_SD  = 8;     // PB0
// SD polarity. The Proteus IR2104 model ENABLES the driver when SD is HIGH
// (measured in simulation). The Infineon/IR datasheet describes SD high = shutdown,
// so for real hardware set this to false and check the datasheet.
const bool SD_ENABLE_HIGH = true;
const uint8_t SD_ON_LEVEL  = SD_ENABLE_HIGH ? HIGH : LOW;
const uint8_t SD_OFF_LEVEL = SD_ENABLE_HIGH ? LOW  : HIGH;
const uint8_t PIN_OCP = 2;     // INT0
const uint8_t PIN_POT = A0;
const uint8_t PIN_VFB = A1;
const uint8_t PIN_ISN = A2;
const uint8_t PIN_VIN = A3;

// ---------------- Hardware constants (edit to match your parts) ----------------
const float VREF       = 5.00;      // measure the Arduino 5V pin and enter it here
const float R_FB_TOP   = 15000.0;   // R3
const float R_FB_BOT   = 10000.0;   // R4
const float VOUT_DIV   = (R_FB_TOP + R_FB_BOT) / R_FB_BOT;   // 2.5

const bool  USE_VIN_SENSE     = false;  // true once A3 divider is wired (else VIN_NOM is used)
const bool  USE_CURRENT_SENSE = false;  // true once A2 current amp is wired (else limit is off)
const bool  USE_HW_TRIP       = false;  // true once the comparator is wired to pin 2
const float R_IN_TOP   = 47000.0;
const float R_IN_BOT   = 10000.0;
const float VIN_DIV    = (R_IN_TOP + R_IN_BOT) / R_IN_BOT;   // 5.7
const float VIN_NOM    = 12.0;
const float VIN_MIN    = 9.5;       // below this the converter stays off (IR2104 needs >= 10 V)

const float I_V_PER_A  = 1.0;       // 10 mohm shunt x INA180A3 (100 V/V) = 1 V per amp
const float I_OFFSET_V = 0.0;       // amp output at 0 A (trim if it reads non-zero)

const float VOUT_MAX   = 11.0;      // pot full-scale / highest allowed target
const float I_LIMIT    = 2.5;       // software current limit, amps
                                    // (hardware trip should be set higher, ~3.5-4 A)

// ---------------- PWM ----------------
const uint16_t PWM_TOP  = 319;      // 16 MHz / (319 + 1) = 50 kHz
const float    DUTY_MAX = 0.95;     // keeps some low-side time to refresh the bootstrap cap

// ---------------- Controller tuning (duty = 0..1) ----------------
const float KP        = 0.005;      // duty per volt of error (kept small on purpose)
const float KI        = 2.0;        // duty per volt-second of error
const float TRIM_MAX  = 0.15;       // integral may add/subtract at most 15 % duty
const float RAMP_V_PER_S = 10.0;    // soft-start / setpoint slew
const float ILIM_RATE    = 20.0;    // V/s the target is pulled down while over I_LIMIT
const unsigned long LOOP_US  = 1000;   // control period
const unsigned long RETRY_MS = 1000;   // wait after a hardware trip

// ---------------- State ----------------
volatile bool tripped = false;
unsigned long tripAt = 0;
uint8_t tripCount = 0;

bool  enabled = false;
bool  usePot = true;
float fixedTarget = 5.0;

float integral = 0, rampSet = 0, limitCap = VOUT_MAX, potF = 0;
float vout = 0, iout = 0, vin = VIN_NOM, target = 0, duty = 0;

// ---------------- Helpers ----------------
float readAvg(uint8_t pin, uint8_t n) {
  uint16_t sum = 0;
  for (uint8_t i = 0; i < n; i++) sum += analogRead(pin);
  return (float)sum / n;
}

float countsToVolts(float counts) { return counts * (VREF / 1024.0); }

// Hardware over-current: kill both MOSFETs immediately (SD = PB0 = pin 8)
void tripISR() {
  if (SD_ENABLE_HIGH) PORTB &= ~_BV(PB0); else PORTB |= _BV(PB0);
  tripped = true;
}

void outputsOff() {
  digitalWrite(PIN_SD, SD_OFF_LEVEL);
  OCR1A = 0;
  enabled = false;
  integral = 0;
  duty = 0;
}

void handleSerial() {
  if (!Serial.available()) return;
  char c = Serial.peek();
  if (c == 'p' || c == 'P') {
    usePot = true;
    Serial.read();
  } else {
    float v = Serial.parseFloat();
    if (v >= 0.0 && v <= VOUT_MAX) {
      fixedTarget = v;
      usePot = false;
    }
  }
  while (Serial.available()) Serial.read();
}

void printStatus() {
  static unsigned long lastPrint = 0;
  if (millis() - lastPrint < 250) return;
  lastPrint = millis();
  Serial.print(F("Set "));    Serial.print(target, 2);
  Serial.print(F("V | Out ")); Serial.print(vout, 2);
  Serial.print(F("V | I "));   Serial.print(iout, 2);
  Serial.print(F("A | Vin ")); Serial.print(vin, 1);
  Serial.print(F("V | Duty ")); Serial.print(duty * 100.0, 1);
  Serial.print(F("% | "));
  if (tripped)        Serial.print(F("TRIPPED"));
  else if (!enabled)  Serial.print(F("OFF"));
  else if (limitCap < target) Serial.print(F("CURRENT LIMIT"));
  else                Serial.print(F("RUN"));
  Serial.print(F(" | trips ")); Serial.println(tripCount);
}

// ---------------- Setup ----------------
void setup() {
  // Safe state first: driver shut down, PWM low
  pinMode(PIN_SD, OUTPUT);
  digitalWrite(PIN_SD, SD_OFF_LEVEL);
  pinMode(PIN_PWM, OUTPUT);
  digitalWrite(PIN_PWM, LOW);
  pinMode(PIN_OCP, INPUT);

  // Timer1: fast PWM, TOP = ICR1 (mode 14), no prescaler, non-inverting on OC1A
  TCCR1A = _BV(COM1A1) | _BV(WGM11);
  TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10);
  ICR1  = PWM_TOP;
  OCR1A = 0;

  // ADC clock 250 kHz (prescaler 64) for faster conversions
  ADCSRA = (ADCSRA & ~0x07) | 0x06;

  Serial.begin(9600);
  Serial.setTimeout(20);

  if (USE_HW_TRIP) attachInterrupt(digitalPinToInterrupt(PIN_OCP), tripISR, RISING);

  potF = (analogRead(PIN_POT) / 1024.0) * VOUT_MAX;
  Serial.println(F("Buck controller v2 ready. Type a voltage (e.g. 5) or p for pot."));
}

// ---------------- One control step ----------------
void controlStep(float dt) {
  // Measurements
  vout = countsToVolts(readAvg(PIN_VFB, 4)) * VOUT_DIV;
  if (USE_CURRENT_SENSE) iout = (countsToVolts(readAvg(PIN_ISN, 2)) - I_OFFSET_V) / I_V_PER_A;
  else                   iout = 0.0;
  if (USE_VIN_SENSE) vin = countsToVolts(readAvg(PIN_VIN, 2)) * VIN_DIV;
  else               vin = VIN_NOM;

  float potV = (analogRead(PIN_POT) / 1024.0) * VOUT_MAX;
  potF += 0.02 * (potV - potF);                 // smooth the pot
  target = usePot ? potF : fixedTarget;

  // Should the converter be running?
  bool wantOn = (target >= 0.2) && (vin >= VIN_MIN);
  if (!wantOn) {
    if (enabled) outputsOff();
    return;
  }

  if (!enabled) {                               // start from the present output voltage
    integral = 0;
    rampSet  = vout;
    limitCap = VOUT_MAX;
    digitalWrite(PIN_SD, SD_ON_LEVEL);
    enabled = true;
  }

  // Software current limit: pull the allowed target down while over the limit
  if (iout > I_LIMIT) limitCap -= ILIM_RATE * dt;
  else                limitCap += ILIM_RATE * dt;
  limitCap = constrain(limitCap, 0.0, VOUT_MAX);

  float tgt = target;
  if (tgt > limitCap) tgt = limitCap;

  // Slew toward the target (soft start, faster on the way down)
  float step = RAMP_V_PER_S * dt;
  if (rampSet < tgt) rampSet = min(rampSet + step, tgt);
  else               rampSet = max(rampSet - 4.0 * step, tgt);

  // Control law: feedforward duty + small P + integral trim
  float err = rampSet - vout;
  integral += KI * err * dt;
  integral = constrain(integral, -TRIM_MAX, TRIM_MAX);

  duty = rampSet / vin + KP * err + integral;
  duty = constrain(duty, 0.0, DUTY_MAX);

  uint16_t counts = (uint16_t)(duty * (PWM_TOP + 1) + 0.5);
  if (counts > PWM_TOP) counts = PWM_TOP;
  OCR1A = counts;
}

// ---------------- Main loop ----------------
void loop() {
  static unsigned long lastUs = 0;

  handleSerial();

  // Hardware trip: stay off, then retry after RETRY_MS (hiccup mode)
  if (tripped) {
    if (tripAt == 0) {
      tripAt = millis();
      tripCount++;
      outputsOff();
      digitalWrite(PIN_SD, SD_OFF_LEVEL);
    }
    if (millis() - tripAt >= RETRY_MS) {
      tripped = false;
      tripAt = 0;
    }
    printStatus();
    return;
  }

  unsigned long now = micros();
  if (now - lastUs >= LOOP_US) {
    float dt = (now - lastUs) * 1e-6;
    lastUs = now;
    if (dt > 0.01) dt = 0.01;                   // ignore long gaps (e.g. first pass)
    controlStep(dt);
  }

  printStatus();
}