How to design Arduino buck converter with feedback

Why Use Feedback in Buck Converters?

Feedback is the cornerstone of stable voltage regulation. It ensures the output voltage remains consistent even when the input voltage or load changes. Arduino provides an excellent platform to implement feedback control systems due to its ease of programming and flexibility. If you're interested in advanced control techniques like adaptive control or fuzzy logic, these concepts can also be applied to refine your feedback loop further.

Components You’ll Need

To build the buck converter, you will need the following components:

1. Arduino Board: Acts as the controller for the PWM signal.
2. BC547 Transistor: Connects to Arduino's PWM pin to drive the MOSFET.
3. IRF4905 MOSFET: Handles the high current to the load.
4. 1N5822 Schottky Diode: Ensures fast switching and minimal power loss.
5. Inductor (100µH): Smoothens the current flow.
6. Capacitor (470µF): Filters out voltage ripples.
7. Resistor Network (15kΩ and 10kΩ): Creates a voltage divider for feedback.
8. 12V Battery and Bulb: Provides power and serves as the load.
9. Potentiometer (10kΩ): Adjusts the target voltage.

Circuit Schematic

Below is the circuit diagram of the Arduino buck converter with feedback.

Input and Feedback Mechanism

The potentiometer sets the desired output voltage, while the feedback pin reads the actual output voltage through a resistive voltage divider. This feedback mechanism enables the Arduino to adjust the PWM signal dynamically, ensuring the output voltage matches the target. You can explore the concept of feedforward control to enhance stability in more complex designs.

Role of Each Component

• 1N5822 Schottky Diode: With its low forward voltage drop, the 1N5822 improves efficiency and minimizes heat generation.
• Inductor and Capacitor: These work together to filter out noise and stabilize the output voltage.
• BC547 and IRF4905: The BC547 controls to drive the IRF4905, a P-channel MOSFET that handles the high current load. 
  

 For tips on designing the hardware side of a buck converter, you can refer to this detailed guide on designing buck converters.

Software Implementation

The software is responsible for controlling the PWM signal based on the target and measured voltages. Below is the Arduino code for using Arduino as the feedback controller for the Buck Converter:

/*
 * COMPLETE BUCK CONVERTER CONTROLLER by ee-diary
 * Logic: PI Control (Proportional-Integral)
 * Output: Pin 9 (High Frequency ~31kHz)
 * Feedback: Pin A1 (15k/10k Divider)
 * Input: Pin A0 (10k Potentiometer)
 */

// --- Pin Definitions ---
const int pwmPin = 9;      // Output to MOSFET Driver (Q1)
const int potPin = A0;     // Potentiometer Input
const int feedbackPin = A1; // Feedback from Voltage Divider

// --- PI Control Constants ---
// --- NEW STABLE TUNING ---
float Kp = 1;   // Very gentle reaction
float Ki = 0.2;  // Very slow correction
float integral = 0;  // Stores the accumulated error

void setup() {
  pinMode(pwmPin, OUTPUT);
  pinMode(potPin, INPUT);
  pinMode(feedbackPin, INPUT);

  // Set Timer 1 for High-Frequency PWM (~31.37 kHz) on Pin 9
  // This keeps the inductor silent and the output smooth
  TCCR1A = _BV(COM1A1) | _BV(WGM10);
  TCCR1B = _BV(CS10);

  Serial.begin(9600);
  Serial.println("System Initialized...");
}

void loop() {
  // 1. Calculate Target Voltage from Pot (0.0 to 12.0V)
  float targetVoltage = analogRead(potPin) * (12.0 / 1023.0);

  // 2. Calculate Actual Voltage from Feedback (A1)
  // Divider Ratio: (15k + 10k) / 10k = 2.5
  float measuredVoltage = analogRead(feedbackPin) * (5.0 / 1023.0) * 2.5;

  // 3. Calculate Error
  float error = targetVoltage - measuredVoltage;

  // 4. Integral Logic with Anti-Windup
  // Only accumulate if we are close to the target to prevent "runaway"
  if (abs(error) > 0.1) { 
    integral += error;
  }
  
  // Constrain integral to prevent it from getting stuck (Windup)
  integral = constrain(integral, -50, 50); 

  // 5. PI Calculation
  float controlOutput = (error * Kp) + (integral * Ki);

  // 6. Convert to PWM Value (0-255)
  int pwmValue = constrain((int)controlOutput, 0, 255);
  
  // Safety: If the target is basically zero, force everything OFF
  if (targetVoltage < 0.2) {
    pwmValue = 0;
    integral = 0;
  }

  // Write PWM to Timer 1 Register (Pin 9)
  OCR1A = pwmValue;

  // 7. Debugging Output (Every 250ms)
  static unsigned long lastPrint = 0;
  if (millis() - lastPrint > 10) {
    Serial.print("Target: "); Serial.print(targetVoltage, 1);
    Serial.print("V | Actual: "); Serial.print(measuredVoltage, 1);
    Serial.print("V | PWM: "); Serial.println(pwmValue);
    lastPrint = millis();
  }
}
}