The idea: switch and store

Reference: the converter we are working on.

In Chapter 1 we got the headline result, $V_{out} = D\,V_{in}$, by averaging the chopped switch node. That view is quick, but it treats the inductor and capacitor as a black box labelled "filter". In this chapter we open the box and watch the inductor do its work - not with numbers yet, but to build the intuition for why the current looks the way it does. (The numbers and the part-sizing come in Chapter 3.)

What is actually in the box

You have already met the whole circuit in Figure 1. Stripped to essentials, it is just two parts:

• the half-bridge - the two switches $Q_1$ and $Q_2$ that take turns chopping the input, from Chapter 1, and
• the L-C filter - an inductor that resists sudden changes in current, followed by a capacitor that resists sudden changes in voltage.

The half-bridge makes the chopped square wave at $v_m$; the L-C filter turns it into smooth DC. The art of the converter is in how the inductor passes energy from input to output, packet by packet.

How the inductor current behaves

The one fact you need about an inductor is its defining law:

In words: the voltage across an inductor is proportional to how fast its current is changing. Turn that around and it says something more useful for us - the current is the running total (the integral) of the voltage applied to it:

So if you put a steady voltage across an inductor, its current ramps in a straight line; flip the voltage negative, and the current ramps back down. The current does not jump - it accumulates.

Now look at our converter. The inductor sits between the switch node $v_m$ on its left and the output $V_{out}$ on its right, so the voltage across it is always $v_L = v_m - V_{out}$. There are two phases (Figure 7):

Figure 7 Top: the voltage across the inductor, $v_L = v_m - V_{out}$. Bottom: the current it produces. A positive voltage ramps the current up (Phase 1); a negative voltage ramps it down (Phase 2). The current is the integral of the voltage.

Phase 1 - top switch closed ($v_m = V_{in}$). The inductor sees $v_L = V_{in} - V_{out}$, a positive voltage. Its current ramps up in a straight line - energy flows from the input, through the inductor, into the battery and the capacitor. The inductor is filling up.

Phase 2 - bottom switch closed ($v_m = 0$). Now the inductor sees $v_L = -V_{out}$, a negative voltage. Its current ramps back down, delivering its stored energy onward. The inductor is emptying out.

Fill a little, empty a little, over and over. The current never stops - it just rides up and down by a small amount. That small up-and-down is the ripple, and how big it is, and how you control it, is the whole of Chapter 3.

Where the energy is kept

Why can the inductor keep pushing current in Phase 2, when the input has been disconnected? Because it has stored energy in its magnetic field. A current flowing through an inductor builds a magnetic field around it, and that field holds an amount of energy

In Phase 1 the inductor soaks up energy (field grows, current rises); in Phase 2 it gives that energy back (field collapses, current falls), and it is this stored energy that keeps the current flowing into the battery even with the input switched away. The same stored energy is why an inductor "pushes back" against sudden changes - to change its current quickly you would have to change its stored energy quickly, and it resists exactly that.

The same answer, seen through the inductor

This two-phase picture quietly gives us $V_{out} = D\,V_{in}$ a second time, from a completely different starting point. The argument is worth seeing, because it is the one that leads to ripple and sizing in the next chapter.

In steady state the inductor current must end each cycle exactly where it started - otherwise it would creep away every cycle, which is not a steady state. So whatever the current ramps up in Phase 1, it must ramp back down by the same amount in Phase 2. Since the ramp rate is set by the voltage (the inductor law again), the voltage × time of the two phases must balance:

Here $T_s$ is one switching period, so Phase 1 lasts $D\,T_s$ and Phase 2 lasts $(1-D)\,T_s$. Cancel $T_s$, multiply out, and the $V_\text{out}$ terms collect to give, once again,

Designing the filter: choosing L and C

Reference: the converter we are working on.

In Chapter 2 we saw how the inductor current behaves - ramping up, then down, every cycle. That up-and-down swing is the ripple, and this chapter is about choosing the inductor $L$ and capacitor $C$ to keep it in check. But before the formulas, the obvious question: why do we care about ripple at all? Two reasons, and they are why nobody just throws in a tiny inductor and calls it done.

Ripple costs you efficiency. The ripple is alternating current, and alternating current is what creates losses in the magnetics and the capacitor. A bigger current ripple swings the inductor's magnetic field harder every cycle, which raises its core loss, and it pushes more alternating current through the output capacitor, which heats it up through its ESR (the small internal resistance every real capacitor has). (Capacitors are even rated for a maximum ripple current for exactly this reason - exceed it and the part overheats and ages early.) So more ripple is not free: it quietly turns into extra heat in the very parts you were trying to keep small. The losses we meet in the next chapter are partly set by the ripple you choose here.

Ripple is noise, and noise is regulated. A converter chopping tens of amps on and off tens of thousands of times a second is, electrically, a little radio transmitter. The switching ripple shows up as electromagnetic interference (EMI) - both conducted out along the input and output wires and radiated into the air - and it can disturb other electronics nearby. This is not optional to care about: almost any product you build and sell has to pass EMC/EMI certification, which sets hard ceilings on how much electrical noise it may emit. Smaller ripple is one of the main levers for staying under those limits, so the ripple target is often dictated as much by what you are allowed to emit as by what the load needs.

How tight the ripple target needs to be is not something the buck decides on its own - it depends on the system around the converter: how much ripple the neighbouring devices (the battery, the downstream electronics) can tolerate, and the voltage and current limits they impose. Design always starts with those external requirements. With that settled, the rest of the chapter is the how - the two formulas that turn a ripple target into an actual inductor and capacitor.

Sizing the inductor

How big is the ripple? During Phase 1 the inductor sees a fixed voltage $V_\text{in}-V_\text{out}$ for a time $D\,T_s$. Using the inductor law in the form $\Delta i = v\,\Delta t / L$, the peak-to-peak current ripple is

Figure 8 The same triangle from Chapter 2, now with its size marked. The peak-to-peak swing $\Delta i_L$ is what the inductance controls.

This is the inductor's design equation. The ripple you want is a choice; rearrange for $L$ and you have your inductor:

Bigger $L$ means smaller ripple, but a physically larger, heavier, more expensive part that responds more slowly to changes. It is always a trade-off.

Notice that the switching frequency $f_{sw}$ sits in the denominator too: the faster you switch, the smaller the ripple. The reason is simple - at a higher frequency each on-time is shorter, so the current has less time to ramp before the switch flips back. Double the switching frequency and you halve the ripple, for the same inductor. (That sounds like a free way to shrink the ripple, but Chapter 4 shows the catch: switching faster costs more loss.)

How much ripple should you aim for? That is a design choice, and it varies a lot from one application to the next. A figure often quoted as a starting point is around 30-40 % of the full load current - but plenty of applications demand far less, and a value that is perfect in one design can be completely wrong in another. Treat any rule of thumb as a starting point to be checked against your requirements, not a law.

The capacitor and the output ripple

The inductor's ripple current has to go somewhere, and the capacitor is what catches it so the battery sees a smooth voltage. The capacitor deserves the same care we gave the inductor - and it behaves as the inductor's exact mirror image.

One thing worth being clear about: the inductor and capacitor together form a simple L-C filter, so the inductor actually affects the voltage ripple too - a bigger $L$ means less current ripple, and less current ripple means less voltage ripple. So why did we size $L$ from the current ripple and leave the voltage ripple to $C$? Because the current ripple is the thing that really matters for the inductor (it sets the peak current and the core loss), and the capacitor has only a small say over it - a bigger $C$ flattens the output voltage a little, which slightly reduces the current ripple. So when you size for current ripple you can safely ignore $C$. The natural division of labour is: pick $L$ for the current ripple, then pick $C$ for the voltage ripple. You could lean on a bigger inductor to shrink the voltage ripple instead, but you usually don't, because that is the capacitor's cheaper job.

Where the inductor's law was "voltage sets the rate of change of current", the capacitor's law is the reverse:

In words: the current into a capacitor sets how fast its voltage changes, so the capacitor voltage is the running total (integral) of the current poured into it. Inductor: current is the integral of voltage. Capacitor: voltage is the integral of current. A neat duality.

Now, which current flows into the capacitor? Look at the output node, where three wires meet (Figure 9): the current $i_L$ arriving from the inductor, the current $i_R$ leaving into the load, and the current $i_C$ going into the capacitor. Kirchhoff's current law says what arrives must leave:

Figure 9 The output node. What the inductor delivers either feeds the load or charges the capacitor: $i_C = i_L - i_R$.

Here is the key simplification. The output voltage ripple is tiny compared with $V_{out}$ - millivolts on tens of volts - so for the purpose of the load, the output is essentially constant, and the load current $i_R \approx I_{out}$ is steady DC. The inductor current, meanwhile, is its average ($I_{out}$) plus the triangular ripple. Subtract the steady part and what is left - the ripple - has nowhere to go but into the capacitor:

So the capacitor current is a triangle centred on zero, half the inductor's peak-to-peak ripple in each direction. And since the capacitor voltage is the integral of that current, the output ripple is the running total of this triangle (Figure 10): the voltage rises while $i_C$ is positive (capacitor charging) and falls while $i_C$ is negative (discharging), lagging the current by a quarter cycle.

Figure 10 Top: the capacitor current, the ripple part of $i_L$, swinging $\pm\Delta i_L/2$ about zero. Bottom: the output-voltage ripple is its integral - note the vertical scale is millivolts.

Integrating that triangle over the half-cycle it is positive gives the charge delivered to the capacitor, $\Delta Q = \tfrac12 \cdot \tfrac{T_s}{2} \cdot \tfrac{\Delta i_L}{2}$, and a charge $\Delta Q$ on a capacitor $C$ raises its voltage by $\Delta Q / C$. Working it through gives the output-ripple formula:

One caveat the clean formula hides: a real capacitor has a small internal resistance, its ESR (equivalent series resistance). The ripple current flowing through the ESR makes its own little voltage, $\Delta i_L \times \text{ESR}$, which often dominates the real output ripple. This is why datasheets obsess over low-ESR capacitors - and it comes back to bite us in the control chapters.

When the current hits zero: CCM and DCM

Everything so far assumed the inductor current stays positive. But the average current is set by the load, and as you lighten the load that average slides down while the triangle keeps its size. Eventually the bottom of the triangle reaches zero. What happens next depends entirely on the bottom device - and this is exactly where the diode-versus-switch choice matters (Figure 11).

Figure 11 In the diode (asynchronous) buck, the bottom path is a diode. A diode only lets current flow one way.

A diode only allows current in one direction - it physically blocks any reverse flow. So in the diode buck, when the inductor current tries to go negative, it simply can't: the diode stops conducting, and the current sits flat at zero until the next cycle begins. That is discontinuous conduction mode (DCM). A synchronous buck, by contrast, has a transistor there that conducts both ways, so the current is free to swing negative and the converter stays in continuous conduction mode (CCM) at any load. Figure 12 shows the two side by side.

Figure 12 Heavy load: the current never reaches zero (CCM). Light load with a diode: the current hits zero and rests there for part of each cycle (DCM), because the diode blocks reverse flow.

Where the energy goes

Reference: the converter we are working on.

A real buck is not 100 % efficient - it is just very good. But before we open up where the missing few percent go, it is worth being clear on why we care so much, because the answer is not what most people assume.

It is tempting to think efficiency is just about the energy you waste - a 97 % converter throws away 3 % of the power, and that is that. But the wasted power does not vanish; it turns into heat, right there inside the converter. And that heat is the real problem.

Every component has a temperature it can tolerate, and no more. A MOSFET has a maximum junction temperature; push past it and it degrades or fails. The inductor's core loses its magnetic properties when it gets too hot, and its winding insulation cooks. Electrolytic capacitors dry out and age dramatically faster the hotter they run. So the losses are not just an electricity bill - they are heat you are obliged to get out of the converter before it damages itself.

That reframes the whole point of efficiency. In our 1 kW converter, going from 97 % to 94 % efficient doubles the wasted power from about 30 W to 60 W - and now you have twice as much heat to deal with. You are then left with three ways to spend money: buy beefier, higher-temperature-rated components that can survive the heat; add cooling (bigger heatsinks, a fan) to carry it away; or invest in making the converter more efficient in the first place so the heat is never produced. Efficiency is really a choice about which of those costs you pay.

So this chapter opens up the small fraction of power that does not reach the battery - because that lost power is heat, and heat is what decides how you cool the converter, how big the parts must be, and how long it lasts.

Three families of loss

Every loss in a buck falls into one of three buckets, and the differences between them explain the whole efficiency story.

• Conduction loss - the price of carrying current. Current flowing through a transistor's on-resistance $R_{ds(on)}$, and through the inductor's winding resistance (its DCR), burns $I^2 R$. It grows with the square of the load current.
• Switching loss - the price of changing state. Every time a transistor turns on or off there is a brief moment when it has both voltage across it and current through it, and that overlap burns energy. Charging the gate and the device's capacitances costs a fixed sip each cycle too. All of it is paid per switching cycle, so it grows with frequency but barely cares about the load.
• Magnetic (core) loss - the price of cycling the inductor's core. Every cycle, the magnetic field in the core is built up and torn down, and the core material resists that (hysteresis), while small induced eddy currents swirl inside it. This heats the core whether the load is heavy or light, and it grows with frequency and with how hard you swing the magnetic field. With a cheap core it can be surprisingly large.

It helps to know what each loss actually depends on, because that is what tells you which knob changes which loss. For the curious, here are the simplest forms (each is an approximation - real life is messier, especially the core loss):

• Conduction depends on current and resistance: $P_\text{cond} = I^2 R$. Nothing you can do about the current (the load sets it), so you fight this with lower-resistance parts.
• Switching depends on the switching frequency: each on/off transition wastes a fixed packet of energy, so $P_\text{sw} \approx \tfrac{1}{2}\,V_\text{in}\,I\,(t_r + t_f)\,f_{sw}$ - double the frequency, double this loss.
• Core (magnetic) is genuinely complex - it depends on the core material, the frequency, and the detailed shape of the magnetic cycling, and the full description (the Steinmetz equation) raises more questions than it answers. But on a surface level the one thing worth holding onto is simple: there is a positive relationship between the current ripple and the core loss. The more ripple you push through the inductor, the more its core heats up - and the loss climbs with switching frequency on top of that. (Cheap core materials simply lose more for the same ripple.)

The efficiency curve

Put those together and you get the characteristic efficiency curve every buck datasheet shows (Figure 13). At very light load the delivered power is tiny but you are still paying the fixed switching and core losses every cycle, so efficiency is poor. As load rises those fixed costs are spread over more delivered power and efficiency climbs to a peak. Push the load higher still and the $I^2R$ friction takes over, dragging efficiency back down.

Figure 13 Efficiency versus output power, computed from a simple loss model with illustrative (representative) device values - it shows the characteristic shape, not a measurement of any specific converter. Light load is dominated by the fixed switching and core losses; heavy load by $I^2R$ conduction. The peak sits in between.

Figure 14 shows the same story as a loss budget at two operating points. At light load the bars are mostly switching and core; at heavy load conduction towers over everything else.

These three families are the big ones, but they are not the whole list. A real converter also burns a little power on housekeeping - the controller and its firmware, the gate drivers, the voltage references and sensing, all drawing a small steady current whether or not you are delivering any load. And if the design needs active cooling, the fan itself costs power. None of these usually dominate, but they are why a real efficiency number never quite reaches the figure the three families alone would predict - especially at very light load, where the fixed housekeeping draw is competing with very little delivered power.

Figure 14 Where the watts go, at light load versus heavy load. The mix flips completely. (Illustrative values.)

Why pay for the second switch?

Now we can settle the synchronous-versus-diode question. The diode buck (Figure 6, back in Chapter 1) is cheaper and needs no gate drive, but the diode has a stubborn problem: while it conducts it drops a forward voltage $V_F$ of perhaps 0.4-0.7 V, and all the load current flows through that drop. At 20 A and $V_F = 0.5$ V, during the half of the time the diode conducts, that is roughly 5 W wasted - and it scales straight up with current. A synchronous MOSFET instead drops only $I \times R_{ds(on)}$, which for a milliohm-class device is far smaller. That is why high-current converters pay for the second switch: at heavy load the MOSFET's tiny $I R_{ds(on)}$ beats the diode's fixed $V_F$ handily.

The twist is at light load, where keeping the synchronous switch on lets current flow backwards and wastes energy circulating it. So good controllers make the bottom MOSFET act like a diode at light load - diode-emulation, turning it off when the current reaches zero (back into DCM). That is the best of both worlds, and it is why a good charge controller stays efficient whether the sun is blazing or barely up.

A switch also conducts both ways, where a diode conducts only one, so a two-switch converter can be bidirectional - useful for a battery that must both charge and discharge. But if you only ever run one direction (our solar charge controller only charges), you don't need that, and a cheaper unidirectional part - a diode, or a simple switch - is perfectly fine.

Controlling a buck: an overview

Reference: the converter we are working on.

Up to now we have set the duty cycle $D$ by hand. From here on a controller sets it automatically, moment to moment. This chapter is the map: what we choose to control, and why. The detailed how - the actual controllers - comes in the chapters after.

What you control depends on the system around it

A buck never sits alone. It sits between a source on its input and a load on its output. In our running example the source is the solar string and the load is the battery. That surrounding system decides what we control.

The input side is essentially fixed - the source hands us a voltage we do not get to choose (and which drifts as the sun and temperature change). What we can steer is the output. For a buck that almost always means we control the output voltage: we want a steady voltage for the battery, no matter how the input or the load wanders.

Controlling the voltage

To hold the output voltage, the controller does the obvious thing: it looks at the output, compares it to the target $V_{ref}$ (which the MPPT or charge logic asks for), and adjusts the duty cycle to close the gap - output too low, push $D$ up; too high, ease it down. To do that, the controller has to know the output voltage. The simplest way is just to measure it, which is what we will assume throughout. (You do not strictly have to measure it - it is also possible to estimate the output from other quantities, so-called sensorless control - but that usually costs you accuracy or computation, so a direct measurement is the normal choice.) That is the voltage controller, sketched below.

The voltage controller in outline: measure the output, compare to the target, set the duty. We open up the controller box in Chapter 7.

For many buck converters, that is the whole story - one loop, holding the voltage.

Why also control the current

A voltage-only controller has one blind spot: it cares only about the voltage, and lets the current do whatever that requires. Most of the time that is fine. But during a big disturbance - a sudden jump in the reference, or a load step - the controller may demand a large change in voltage, and the inductor current can surge to whatever value delivers it. Large currents are bad news on their own: more current means more loss, which means more heat, which is what eventually damages the switches and the battery (Chapter 4). So we want to keep the current in check.

(Worth knowing: a real converter also has a separate, fast hardware protection that trips on a dangerous current spike all by itself - we come back to that in Chapter 8. What we are about to add is the controller's own handle on the current.)

So in many designs we add a second, inner loop that controls the inductor current directly. The outer voltage loop no longer sets the duty itself - it asks for a current (a target $i_{ref}$), and the inner loop makes the current follow it. This nesting is cascade control (sketched below), and its decisive advantage is that you can simply cap the current target: the converter then physically cannot exceed a safe current, however hard it is pushed.

Cascade control in outline: the voltage loop commands a current, the current loop delivers it. Detail in Chapter 8.

Voltage, current, or both?

So "what do you control?" has two answers, and which you pick is a property of the system, not the converter:

• Voltage only - the simplest choice, and enough when nothing bad happens if the current does whatever it likes.
• Voltage and current (cascade) - when you must keep the current in check: avoid spikes, limit inrush, protect the battery and the switches.

Neither alone is the full picture: voltage control sets the output the load needs, but does not protect the hardware; current control protects the hardware, but on its own does not set the output. Cascade gives you both, which is why it is the workhorse - and why we build up to it.

The last link: PWM

There is one piece still missing. Both controllers output a duty cycle - a number between 0 and 1. But the switches only understand on and off. The bridge between the controller's duty cycle and the actual gate signal is PWM, and it is where we go next.

Making the duty cycle real: PWM

Reference: the converter we are working on.

The controller's whole job, as we will see, is to compute one number: the duty cycle $D$. But the switches do not understand a number like "$0.5$" - they only understand on or off. Pulse-width modulation (PWM) is the small piece that bridges the two: it turns a duty-cycle number into the on/off gate signal $S$ that actually drives the switch.

Why not just control the switch directly?

You might ask why we bother with a duty cycle at all - why not have the controller flip the switch on and off itself? Because a duty cycle is an easy thing to control, and a gate signal is not.

The duty cycle is a smooth, continuous number: it can take any value between 0 and 1, and a controller can nudge it by a hair - from $0.500$ to $0.501$ - to make a tiny correction. The gate signal is the opposite: it is binary, fully on or fully off at every instant, with nothing in between. Controlling that on/off pattern directly is clumsy - to place a switching edge with any precision you would have to decide the switch state extremely often, far faster than the switching itself, just to get fine resolution.

So we split the problem in two. The controller lives in the easy, continuous world of the duty cycle (that is what all the control chapters that follow are about), and one dedicated block - PWM - does the single job of turning that smooth number into the binary pattern the switches need.

A duty cycle is an average

Remember from Chapter 1 that the duty cycle is just the average of the gate signal over a switching period - the fraction of the time the switch is on. So PWM has a simple target: produce a gate signal $S$ that is on for a fraction $D$ of every period.

The standard way to do it sounds more complicated than it is, so do not worry if the next sentence does not click immediately - the plot just below makes it obvious. Generate a ramp carrier that ramps from 0 up to 1 and resets, exactly once per switching period - so the carrier's frequency is the switching frequency $f_{sw}$ - and compare it against the duty cycle:

That comparison is the entire PWM block (Figure below): two inputs - the duty from the controller and the carrier - and one output, the gate $S$.

The PWM block: it compares the controller's duty against the ramp carrier to make the gate signal. The carrier's frequency sets the switching frequency.

When $D$ is large, it sits above the carrier for most of the period, so $S$ is on most of the time. When $D$ is small, the carrier pokes above it for most of the period and $S$ is mostly off. The waveform below shows it for $D = 0.5$: the gate is on for exactly half of each period.

PWM by carrier comparison. Where the duty $D$ (orange) is above the ramp carrier (blue), the gate $S$ is on. The on-time is a fraction $D$ of each period.

In code it is exactly the one-liner the comparison describes - this is the PWM block you will find in the simulator:

// PWM: compare the duty against a ramp carrier in [0,1].
int pwm_step(float duty, float carrier) {
    int S = (carrier < duty) ? 1 : 0;   // upper switch on while duty > carrier
    return S;                           // lower switch takes the complement
}

Controlling the voltage

Reference: the converter we are working on.

Now we open up the voltage controller from the overview. We build it in two steps: first a model that predicts the right duty cycle, then a PI that corrects for everything the model cannot capture. The structure is the one sketched in Chapter 5, repeated below.

Voltage control: a model (feed-forward) sets most of the duty; a PI corrects the rest from the measured output.

Step 1: the model (feed-forward)

We already have a model of the converter - the rule from Chapter 1. Inverting $V_{out} = D\,V_{in}$ tells us the duty that should produce the voltage we want:

This is the feed-forward: a duty we compute straight from the model, before measuring anything. If the converter were ideal and we knew $V_{in}$ exactly, this would be the entire controller - set $D = V_{ref}/V_{in}$ and the output sits at $V_{ref}$ ($50/100 = 0.5$, with our numbers). It is the best we can do from prediction alone.

Step 2: the PI (correcting what the model misses)

But the model is never the whole truth. We do not capture the losses exactly; $V_{in}$ is measured with some error; there is electrical noise; and the components themselves drift - the inductance changes with current and temperature, the capacitance ages, and there are always small effects we never wrote into the equation at all. The feed-forward cannot know about any of this.

So we measure the actual output, form the error $e = V_{ref} - V_{out}$, and add a PI correction on top of the feed-forward:

The PI is precisely the part that handles what the model left out. The proportional term ($K_p\,e$) reacts to the error right now; the integral term ($K_i\!\int e\,dt$) accumulates it, so that even a small, stubborn error - exactly the kind that drift and unmodelled losses produce - is eventually driven to zero.

What it looks like

The figure below shows this controller handling a step up in the reference voltage. The output is driven cleanly to its new target. Now look at the bottom trace: while the voltage is being controlled, the current simply does whatever the voltage demands - here it surges well past the steady value before settling. The voltage controller never looks at the current. Most of the time that is harmless; sometimes, as the next chapter shows, it is not.

Voltage control at startup. Top: the output is driven up to the 50 V target. Bottom: the inductor current is left to surge to nearly 60 A - nothing is controlling it.

Cascade control: voltage outside, current inside

Reference: the converter we are working on.

The single voltage loop works. But almost every serious converter - and the default controller in the simulator - uses a smarter arrangement: cascade control, with two nested loops. It is the standard way to control a buck, and it is worth understanding why.

The idea is to control the inductor current directly with a fast inner loop, and let a slower outer loop decide how much current to ask for. The structure is the one from Chapter 5, repeated below.

Cascade control: the outer voltage loop commands a current $i_{ref}$; the inner current loop delivers it by setting the duty. The inner loop runs faster than the outer.

Two loops, two jobs

Outer loop - voltage. It looks at the output error $e_V = V_{ref} - V_{out}$ and, instead of a duty cycle, produces a current reference $i_{ref}$ - its way of saying "to fix this voltage error, the inductor should carry this much current." Here the model has little to add, so a PI does the work:

Inner loop - current. This is where the model-plus-corrector idea from the last chapter returns in full. We want the inductor current to follow $i_{ref}$. From the converter's behaviour, the duty that holds a steady operating point is $D_{ff} = V_{out}/V_{in}$ (the same relation as before, now using the measured output) - that is the model for the current loop. On top of it, a PI corrects the current error $e_I = i_{ref} - i_L$ and everything the model misses:

So both loops are built the same way we built the voltage controller - a model plus a PI corrector. The feed-forward matters here in practice: without it the current loop is sluggish and overshoots, and with it the current tracks its reference cleanly.

Keep the loops at different speeds

There is one rule about cascade control you cannot skip: the inner current loop must run faster (have a higher bandwidth) than the outer voltage loop. This is not just a nicety - it is what keeps the two loops from fighting each other.

The reason is interference. If the two loops responded at the same speed, they would both react to the same disturbance at the same instant, each one partly undoing the other's correction. The result is a tug-of-war that shows up as oscillation. The cure is separation: make the inner loop several times faster, so the current has already settled before the voltage loop even notices the disturbance. The voltage loop then sees a current that simply does what it asks - clean and already handled - and the two cooperate instead of interfere.

Why bother with two loops?

Three reasons, all practical:

• The inner loop tames the inductor. By forcing the current to follow a command, the fast current loop hides the inductor's dynamics from the outer loop. The voltage loop no longer "sees" a tricky $L$-$C$ system - it just sees something that delivers whatever current it asks for. That makes the outer loop much easier to get right.
• Current limiting comes for free. This is the big one. Because the outer loop's output is the current command, you can simply clamp $i_{ref}$ to a maximum, and the converter then holds the inductor current at that value - it cannot drive a sustained current past the limit (the current may overshoot it briefly on a fast transient, since the inner loop has finite speed, but it cannot hold above it). That protects the switches, the inductor, and (in our solar example) the battery, which must not be charged too hard. Doing this with a plain voltage loop is clumsy; with cascade it is one line.
• Faster, cleaner response to disturbances, because the inner loop reacts to current changes immediately rather than waiting for them to show up as a voltage error.

Two kinds of current limit: software and hardware

The current limit we just described lives in the controller - it is software clamping $i_{ref}$. But there is almost always a second current limit built into the hardware itself, and the two protect against different things.

The software limit (the clamp on $i_{ref}$) guards against sustained over-current: the load draws too much, or the reference is set too high, and the controller simply refuses to command more than the safe value. It shapes the current during normal operation, where "normal" includes things going a bit wrong for a while. But software is far too slow to catch a sudden spike - a short on the output, or a fault transient, can shoot the current up and be gone in a microsecond, long before the control loop takes its next look. Those are caught by a hardware limiter: a fast analog comparator (often a cycle-by-cycle current limit built into the chip) that shuts the switch off the instant the current crosses a threshold, reacting in around a hundred nanoseconds with no software in the loop. If the fault persists, the hardware escalates on its own - retrying in "hiccups" or latching off entirely.

What it looks like

The figure below shows the startup of the same converter, now under cascade control. The voltage still rises to its target - but look at the current. Instead of surging freely to 57 A as it did under voltage control, it is held close to a limit we set: the outer loop asked for far more current than that, but because its command is a current, we simply capped it.

One detail is worth pointing out, because you will notice it the moment you run this and people always ask about it: the inductor current peaks a little above the 30 A limit line. That is not a mistake. We do not clamp the current itself - we clamp the current reference $i_{ref}$, and the inner loop then drives the real current $i_L$ to follow that reference. Like any control loop it has finite speed, so during the fast startup the current overshoots its reference slightly before the loop catches it. The reference is held exactly at the limit; the current tracks it with a small, normal control overshoot. (Want it tighter? Tune the inner loop faster, or lower the limit a touch to leave margin - it is a tuning choice, not a flaw.) Same converter, same startup as the voltage-only case - but now the current is firmly in hand instead of surging to nearly three times the load.

Cascade control at startup. Top: the output reaches target. Bottom: the current reference $i_{ref}$ is clamped at the 30 A limit; the inductor current follows it, overshooting the limit slightly during the fast transient (we limit the reference, not the current itself) before settling to the load current - instead of surging to 57 A as voltage control did.

Where to go next

You now have the whole arc: why we step DC down by chopping and averaging, how the inductor and capacitor behave and how to size them, where the losses go, and how to control the output - from PWM, to a single voltage loop with feed-forward, to the cascade of voltage and current loops that real converters use.

And here is the nice part: every block diagram in these last chapters is implemented for real in the companion simulator, running against a real switched model of the converter. So the best next step is to play. Run the voltage controller, then the cascade; step the load, clamp the current and watch it protect itself; change the gains and feel the response. Every idea in this book has a knob in there waiting for you.

When you are ready for the mirror image of the buck - the converter that steps voltage up, the one that does solar MPPT from the other side - the boost converter guide picks up exactly where this one leaves off.