Measure When a Bridge Rectifier Draws Current After Adding a Reservoir Capacitor
A capacitor across a bridge rectifier can make the output voltage smoother while concentrating the input current into a shorter part of each half-cycle. The capacitor supplies the load between charging intervals. The bridge draws current again when the input can overcome the stored voltage and the two conducting diodes. In this experiment you will measure both effects at once, using a low-voltage sine generator, a fixed load and a removable capacitor.
The measurement is the fraction of each positive and negative half-cycle with at least 0.50 mA of input current in the expected direction. The threshold makes the result repeatable with an oscilloscope and separates it from tiny leakage currents. The plots and example captures are calculated or synthetic.
Connect the bridge and four scope channels
Before connecting any input or output cables, connect the RIGOL DHO804's rear Ground Terminal to earth ground using the supplied ground cable, as required by the DHO800 User Guide. Its Type-C power input does not ground the instrument through the power cord. Use the supplied power adapter. Keep the AFG1022's protective earth connected. The generator cable shield and probe ground clips share G0 as described below; they do not replace this required chassis earth lead.
Use four Vishay 1N5819-E3/54 Schottky rectifier diodes in DO-204AL, also called DO-41. The color band marks the cathode. The exact device is rated 40 V for repetitive peak reverse voltage under its data-sheet conditions. The /54 suffix identifies the manufacturer packaging. The circuit uses two Vishay MRS25 1% metal-film resistors, MRS25000C2200FCT00 for the 220 Ω sense resistor RS and MRS25000C1001FCT00 for the 1.00 kΩ load RL. RL stays connected for all captures.
- Source. Use a Tektronix AFG1022 function generator only. Its coaxial BNC center contact is SOURCE. Connect SOURCE to bridge input AC1 through RS. The BNC shell is the common reference G0 and connects to the bridge's other input, AC2.
- Diodes. For D1 and D2, connect their cathodes to DC+, and their anodes to AC1 and G0, respectively. For D3 and D4, connect their anodes to DC−, and their cathodes to AC1 and G0, respectively. With AC1 positive, D1 and D4 conduct. With AC1 negative, D2 and D3 conduct. The direction through RL stays from DC+ to DC−.
- Load and reservoir. Connect RL between DC+ and DC−. For the middle run, add a Panasonic FR-A
EEUFR1E470polarized capacitor in parallel with RL. The exact part is 47 µF ±20% under its capacitance test conditions, with 25 V rated direct-current voltage. Connect its positive lead to DC+ and its negative stripe lead to DC−. Keep both bridge output nodes separate from the generator shell. - Scope. Use a RIGOL DHO804 with four PVP2350 probes. Connect the channel tips to SOURCE, AC1, DC+ and DC− in that order. Connect all four ground clips to G0. The instrument's probe grounds share an earth reference. Connecting a clip to either bridge output would ground it and change the conducting paths. Use only this function-generator fixture and preserve the instruments' protective earth.
Follow the current in both half-cycles
Set the generator to a 100 Hz sine, 5.00 V peak-to-peak and zero offset, with its High Z display setting. High Z tells the generator to display the expected unloaded voltage. The physical output resistance remains about 50 Ω. For a 2.50 V open-circuit peak, the nominal short-load current estimate is 2.50 V ÷ (50 Ω + 220 Ω) ≈ 9.26 mA, before allowing for diode drops or the actual load. Ignoring the generator resistance gives a conservative nominal resistor-only estimate of about 11.4 mA for the same voltage. The 8 mA limit used by the analyzer screens steady captures. The startup transient is outside the timing comparison.
Subtract the synchronous scope channels. Input current is IIN = (CH1 − CH2) ÷ RS, signed positive into AC1. The differential output is VOUT = CH3 − CH4. The input current reverses each half-cycle. The differential output retains the same polarity. There are two recharge opportunities per input cycle, so the full-wave ripple repeats near 200 Hz for the nominal source.
The 0.50 mA threshold corresponds to 110 mV across nominal 220 Ω. In this experiment, the current-window fraction means time at or above that threshold divided by the measured half-cycle duration. The same threshold is applied to each half-cycle after choosing its expected sign. Window width and peak are separate readings. A smoother output can coincide with a higher peak.
With the capacitor fitted, the load discharge time constant is 1.00 kΩ × 47 µF ≈ 47 ms, longer than the 5 ms between successive peaks of the rectified input. For intervals with little bridge current, the approximate drop is ΔV ≈ ILOAD × Δt ÷ C. For example, 1.18 mA for 2.5 ms gives about 63 mV. The actual interval depends on the changing diode and resistor voltages, and the threshold is an operational measurement boundary. The fixed 0.22 V drop per diode in the example is an illustrative model parameter. Actual forward voltage changes with current, device and temperature.
| Capture | Window | Ripple |
|---|---|---|
| Bare | 71.7% | 1.622 V |
| Capacitor | 50.4% | 0.063 V |
| Restore | 71.7% | 1.622 V |
In this example, the calculated peak input current rises from about 1.62 to 3.25 mA as the window narrows. The test calculates the peak separately from the qualification gates. The generator settings and fixed output resistance matter; a different source can produce a different peak.
Capture bare, capacitor and restored cases
- Measure RS out of circuit, with the generator disconnected, and enter its actual resistance in ohms when running the analyzer. Check the four diode bands. Leave the capacitor out initially and verify RL across DC+ and DC−. Keep any polarized capacitor in the circuit only in its correct orientation.
- Fit all four probes at 1×, match their on-screen probe factors, and choose DC coupling and 1 MΩ inputs. Before the comparison, put CH1 and CH2 on the same SOURCE node while keeping their grounds on G0. At the final scales, the CH1 − CH2 trace should stay within ±25 mV on a stable sine. This equivalent current is about 0.11 mA, well below the 0.50 mA threshold. If convenient, do the same for CH3 and CH4 with their intended scales. Return every tip to its specified node before recording.
- At about 10 ms/div, trigger on a rising SOURCE edge near zero. Use ordinary sampling and a 10 kpts memory depth. Read the actual time span and confirm 10–40 input midpoint transitions and native time gaps no larger than 110 µs. Choose voltage scales that show the entire signed waveform at each node without clipping. Keep the same four channel scales and probe factors for all three captures.
- Start with the bare bridge and record a settled acquisition. Turn the generator output off to add the capacitor across RL. Re-enable it with the same settings. Wait at least 0.5 s before recording. For the restoration, turn the source output off and let RL discharge the capacitor. Wait at least 2 s and verify less than 0.10 V across DC+ and DC− before handling the leads. Remove only the capacitor and record a third capture with the same source and load.
- Save all four channels from each stopped acquisition using Storage → Save → Choose → Save Wave, with Memory and CSV selected. CSV means comma-separated values. Normalize each file to the columns
time_s,source_v,ac1_v,dc_plus_v,dc_minus_vin seconds and volts. Retain native sample order and timestamps. Save the files asbare.csv,capacitor.csvandrestore.csv.
Analyze the current windows in Python
Download the column template, complete program or archive with synthetic captures and tests. Use Python 3.8 or later and the standard library. Supply the measured value of RS first, followed by the three capture filenames.
python3 bridge_conduction.py 220 bare.csv capacitor.csv restore.csv
python3 bridge_conduction.py 220 synthetic/bare.csv synthetic/capacitor.csv synthetic/restore.csv
The program calculates current and differential output from each four-channel sample. It interpolates the input's midpoint crossings, discards the outer intervals and uses equal counts of positive and negative half-cycles. It interpolates the threshold within each sample interval, then sums the time at or above it. Reporting percentages based on time keeps small sample-spacing variations from changing the metric by row count. It reports both polarity fractions alongside the median half-cycle output average, ripple and peak current.
The analyzer checks sample timing, source frequency and swing, current polarity, and stability across retained halves. It requires both bare halves to spend 50–90% of their time above threshold, and both capacitor fractions to shrink by at least 10 percentage points while staying at or above 15%. The capacitor's ripple must be at most 30% of the bare ripple. Restoring the bare circuit must bring both fractions within five percentage points and ripple within 12% of their original values. These are comparison limits for the fixture.
Exit 0 qualifies the comparison. Exit 1 means a file could not be decoded or was malformed. Exit 2 means the input failed a comparison gate or the command-line arguments were incomplete. If the capacitor run looks unlike the bare and restore controls, check source swing and cap polarity. If only one half fails, check channel polarity, diode orientation and common-reference connections before repeating.
#!/usr/bin/env python3
"""Measure threshold-based bridge current timing from three four-channel captures."""
import argparse
import bisect
import csv
import io
import math
import statistics
from pathlib import Path
HEADER = ("time_s", "source_v", "ac1_v", "dc_plus_v", "dc_minus_v")
MODES = ("bare", "capacitor", "restore")
THRESHOLD = .0005
MAX_BYTES = 1572864
ROUNDING = 1e-9
class Unresolved(ValueError):
"""Capture or control gates could not qualify the result."""
def within(value, low, high):
return low - ROUNDING <= value <= high + ROUNDING
def read_capture(path, shunt):
with path.open("rb") as stream:
data = stream.read(MAX_BYTES + 1)
if len(data) > MAX_BYTES:
raise ValueError(f"{path}: CSV is larger than 1.5 MiB")
table = csv.reader(io.StringIO(data.decode("utf-8-sig"), newline=""), strict=True)
if next(table, None) != list(HEADER):
raise ValueError(f"{path}: expected {','.join(HEADER)}")
samples = []
for index, row in enumerate(table, 1):
if index > 20000 or len(row) != 5:
raise ValueError(f"{path}: too many rows or incorrect field count")
time, source, ac1, plus, minus = map(float, row)
if not all(math.isfinite(value) for value in (time, source, ac1, plus, minus)):
raise ValueError(f"{path}: a field is nonfinite")
if abs(time) > 5 or max(map(abs, (source, ac1, plus, minus))) > 3.5:
raise Unresolved("one channel exceeds ±3.5 V or the timestamps exceed ±5 s")
samples.append((time, source, (source - ac1) / shunt, plus - minus))
if len(samples) < 300:
raise Unresolved("a capture needs at least 300 simultaneous samples")
return samples
def crossings(samples, midpoint):
for (a, va, *_), (b, vb, *_) in zip(samples, samples[1:]):
if va < midpoint <= vb or vb <= midpoint < va:
weight = (midpoint - va) / (vb - va)
yield a + (b - a) * weight, 1 if vb > va else -1
def slice_window(samples, times, start, stop):
def at(time):
previous = bisect.bisect_right(times, time) - 1
a, b = samples[previous], samples[previous + 1]
weight = (time - a[0]) / (b[0] - a[0])
return (time, *(v + (w - v) * weight for v, w in zip(a[1:], b[1:])))
return [at(start), *samples[bisect.bisect_right(times, start):bisect.bisect_left(times, stop)], at(stop)]
def fraction_above(a, b, level):
if min(a, b) >= level:
return 1.0
if max(a, b) < level:
return 0.0
return (max(a, b) - level) / abs(a - b)
def half_cycle(section, polarity):
currents = [point[2] * polarity for point in section]
outputs = [point[3] for point in section]
if min(currents) < -.00024 - ROUNDING or max(currents) > .008 + ROUNDING:
raise Unresolved("current has the wrong polarity or exceeds the fixture limit")
if max(abs(currents[0]), abs(currents[-1])) > .00024 + ROUNDING:
raise Unresolved("shunt current remains large at an input midpoint")
if not within(min(outputs), -.08, 2.7) or max(outputs) > 2.7 + ROUNDING:
raise Unresolved("differential output is reversed or exceeds the fixture range")
duration = section[-1][0] - section[0][0]
on, area = 0.0, 0.0
for index, (left, right) in enumerate(zip(section, section[1:])):
gap = right[0] - left[0]
on += gap * fraction_above(currents[index], currents[index + 1], THRESHOLD)
area += gap * (outputs[index] + outputs[index + 1]) / 2
return on / duration, area / duration, max(outputs) - min(outputs), min(outputs), max(currents)
def analyze(samples):
times = [row[0] for row in samples]
if any(not 0 < b - a <= .00011 + ROUNDING for a, b in zip(times, times[1:])):
raise Unresolved("timestamps must increase with a gap of at most 110 µs")
raw_source = [row[1] for row in samples]
low, high = min(raw_source), max(raw_source)
if not within(high - low, 4.35, 5.15) or abs((low + high) / 2) > .10 + ROUNDING:
raise Unresolved("source peak-to-peak or midpoint is outside its screening range")
edges = list(crossings(samples, (low + high) / 2))
if not 10 <= len(edges) <= 40:
raise Unresolved("capture needs 10–40 input-midpoint crossings")
spans = [b[0] - a[0] for a, b in zip(edges, edges[1:])]
period = 2 * statistics.median(spans)
frequency = 1 / period
if not within(frequency, 98, 102) or any(not within(2 * span / period, .97, 1.03) for span in spans):
raise Unresolved("input frequency or half-cycle timing is unstable")
if any(a[1] == b[1] for a, b in zip(edges, edges[1:])):
raise Unresolved("input polarity transitions do not alternate")
groups = {1: [], -1: []}
interiors = list(zip(edges[1:-2], edges[2:-1]))
for start, end in interiors[:len(interiors) // 2 * 2]:
groups[start[1]].append(half_cycle(slice_window(samples, times, start[0], end[0]), start[1]))
duties = []
complete = groups[1] + groups[-1]
for polarity in (1, -1):
fractions = [row[0] for row in groups[polarity]]
if max(fractions) - min(fractions) > .08 + ROUNDING:
raise Unresolved("same-sign current windows are not steady")
duties.append(statistics.median(fractions))
if max(row[1] for row in complete) - min(row[1] for row in complete) > .12 + ROUNDING:
raise Unresolved("average output changed across the captured half-cycles")
average, ripple, valley, peak = (statistics.median(col) for col in list(zip(*complete))[1:])
return frequency, high - low, *duties, average, ripple, valley, peak
def compare(results):
bare, cap, restored = results
if max(row[1] for row in results) - min(row[1] for row in results) > .25 + ROUNDING:
raise Unresolved("source swing changed by more than 0.25 V between captures")
if bare[5] < 1.0 - ROUNDING or bare[6] > .12 + ROUNDING or cap[6] < .75 - ROUNDING:
raise Unresolved("baseline or capacitor voltage shape does not match this fixture")
if cap[5] / bare[5] > .30 + ROUNDING:
raise Unresolved("with the capacitor, output ripple exceeds 30% of the baseline")
for index in (2, 3):
if not within(bare[index], .50, .90):
raise Unresolved("a bare half-cycle fraction is outside 50–90%")
if cap[index] < .15 - ROUNDING or bare[index] - cap[index] < .10 - ROUNDING:
raise Unresolved("the capacitor did not shorten both current windows by 10 percentage points")
if abs(restored[index] - bare[index]) > .05 + ROUNDING:
raise Unresolved("the original current window did not return after removal")
if abs(restored[5] / bare[5] - 1) > .12 + ROUNDING:
raise Unresolved("original ripple did not return after removal")
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("shunt_ohm", type=float)
for mode in MODES:
parser.add_argument(mode, type=Path)
args = parser.parse_args()
try:
if not within(args.shunt_ohm, 216, 224):
raise Unresolved("use the measured 220 Ω nominal sense resistor (216–224 Ω)")
results = []
print("condition Hz src_Vpp pos_% neg_% mean_V ripple_V peak_mA")
for mode in MODES:
try:
result = analyze(read_capture(getattr(args, mode), args.shunt_ohm))
except Unresolved as error:
raise Unresolved(f"{mode}: {error}") from error
results.append(result)
hz, swing, pos, neg, avg, ripple, _, peak = result
print(f"{mode:<11} {hz:7.3f} {swing:7.4f} {100*pos:7.2f} {100*neg:7.2f}"
f" {avg:6.3f} {ripple:8.4f} {1000*peak:7.3f}")
compare(results)
except Unresolved as error:
print(f"UNRESOLVED: {error}")
return 2
except (ValueError, OSError, csv.Error) as error:
print(f"INPUT ERROR: {error}")
return 1
print("QUALIFIED: the capacitor reduced ripple and shortened both input-current windows.")
return 0
if __name__ == "__main__":
raise SystemExit(main())
The synthetic capture integrates the capacitor current balance as the bridge charges a fixed resistor–capacitor pair. The differential voltage and the input current are the modeled signals. The synthetic individual DC node voltages share an illustrative common-mode reference derived from AC1. In the real off interval their absolute voltages can depend on diode leakage and the paths through the scope probes.
Challenge. How can the supply current be nearly zero while the load still draws current?
The capacitor supplies the load during that interval. Its differential voltage falls gradually as charge leaves it. The input current reappears when the sine through the diode bridge is large enough to replenish this charge. The shunt is in the input path, so it does not measure the current circulating locally from the capacitor through the load.
Related reading
- Read how reservoir capacitors reduce output ripple
- Check the AFG1022 display and actual source voltage
Primary references
- Vishay 1N5817–1N5819 data sheet and Vishay MRS25 data sheet — package polarity, ratings and exact ordering codes.
- Panasonic FR-A series data sheet and the exact EEUFR1E470 product entry — capacitor rating, tolerance and case.
- Texas Instruments SLVA161, Figure 3 — bridge recharge intervals and the capacitor voltage between them. The illustrated supply is a different circuit.
- Tektronix AFG1022 generator data sheet.
- RIGOL DHO800 user guide and PVP2350 probe guide.