The decision to wire a series or parallel circuit dictates how voltage and current distribute across your components, how the system behaves when a part fails, and whether your microcontroller will survive the load. The short answer: use series when you need identical current through all components and have sufficient voltage headroom; use parallel when components require the same voltage and must operate independently.

In this guide, we will break down the node-level topology, contrast the catastrophic failure modes of both configurations, and walk through a real-world design calculating exact resistor values for a 5V LED indicator array driven by an ESP32.

Topology Definitions & Node Mapping

Before picking components, you need to visualize the electron flow. Think of a series circuit as a single water pipe passing through multiple waterwheels in sequence—the flow rate (current) is identical everywhere, but pressure (voltage) drops at each wheel. A parallel circuit is a main pipe splitting into three smaller pipes—the pressure (voltage) at the split is identical, but the flow rate (current) divides based on each pipe's restriction.

Series Topology (Node-to-Node)

In a series configuration, components are daisy-chained end-to-end. Current has only one path to ground.

  • Node A (VCC): Connects to the anode of Component 1.
  • Node B (Junction): Connects the cathode of Component 1 to the anode of Component 2.
  • Node C (GND): Connects the cathode of Component 2 to ground.

Rule: $I_{total} = I_1 = I_2$. Voltage drops add up: $V_{total} = V_1 + V_2$.

Parallel Topology (Node-to-Node)

In a parallel configuration, components share the same two electrical nodes, creating multiple independent paths for current.

  • Node A (VCC): Splits into Branch 1 (Component 1) and Branch 2 (Component 2).
  • Node B (GND): Recombines the cathodes of both branches back to ground.

Rule: $V_{total} = V_1 = V_2$. Branch currents add up: $I_{total} = I_1 + I_2$.

Bench Tip: Never wire raw LEDs directly in parallel without individual current-limiting resistors on each branch. Due to manufacturing tolerances, their forward voltages ($V_f$) will differ slightly. The LED with the lowest $V_f$ will hog the current, overheat, and fail, shifting the burden to the next one in a cascading thermal runaway.

Behavior & Failure Mode Matrix

This table defines exactly how each topology reacts to normal operation and single-component faults. Keep this on your bench.

Parameter Series Circuit Behavior Parallel Circuit Behavior Series Open Fault (Break) Parallel Open Fault (Break)
Voltage Divides across components based on resistance Same across all parallel branches Full source voltage appears across the open break Unchanged across remaining intact branches
Current Identical through every component Divides among branches inversely to resistance Drops to 0A everywhere in the loop Unchanged in intact branches; total draw drops
Resistance $R_T = R_1 + R_2 + R_3...$ (Always increases) $1/R_T = 1/R_1 + 1/R_2...$ (Always decreases) Becomes infinite ($\infty \Omega$) Increases (fewer parallel paths available)
Adding a Load Increases total $R$, reduces total current Decreases total $R$, increases total current draw N/A N/A

The Failure-Mode Contrast: What Breaks at the Extremes?

Understanding how a circuit dies is just as important as how it operates. According to foundational circuit theory outlined by All About Circuits, the fault tolerance of your topology dictates its real-world application.

Series Extremes

  • Open Circuit: The classic 'old Christmas tree light' problem. One filament breaks, the circuit opens, and the entire string dies. However, in industrial 4-20mA sensor loops, an open circuit is a deliberate safety feature. If a wire snaps, the PLC reads 0mA and instantly triggers a 'Wire Break' alarm, distinguishing a fault from a valid low-level sensor reading.
  • Short Circuit: If one component in a series string shorts out (drops to $0\Omega$), the total resistance plummets. The remaining components are suddenly hammered with excess voltage and current, usually leading to cascading thermal failure and magic smoke.

Parallel Extremes

  • Open Circuit: A single branch fails open. Only that specific component stops working; the rest of the parallel network continues operating normally. This is why house wiring, automotive lighting, and USB hubs are wired in parallel.
  • Short Circuit: Catastrophic. If a component in a parallel branch shorts, it creates a near-zero resistance path directly across the voltage source (Node A to Node B). Theoretically, this draws infinite current. In practice, it will instantly trip a breaker, blow a fuse, or melt your PCB traces if unprotected.

Design Walkthrough: 5V Indicator Array

Let's apply this to a real workbench scenario. We need to illuminate three standard 5mm Red LEDs to indicate system status.

Component Specs:

  • LED Forward Voltage ($V_f$): 2.0V
  • LED Target Current ($I_f$): 20mA
  • Power Source: 5V USB Rail
  • Control Signal: ESP32 GPIO (3.3V logic)

Attempt 1: The Series Approach

Can we wire all three LEDs in series on a 5V rail? Let's check the voltage headroom.

$V_{total\_needed} = 2.0V + 2.0V + 2.0V = 6.0V$.

Verdict: Fails immediately. A 5V source cannot push current through a 6.0V requirement. Even if we drop to two LEDs in series ($4.0V$), we only have $1.0V$ left for the current-limiting resistor. $R = 1.0V / 0.02A = 50\Omega$. While mathematically valid, a $1.0V$ drop leaves almost no tolerance for $V_f$ variations or power supply ripple. Series is the wrong topology here.

Attempt 2: The Parallel Approach

We wire three independent parallel branches, each with its own LED and resistor.

Calculating the Branch Resistor:

$R = (V_{source} - V_f) / I_f$

$R = (5.0V - 2.0V) / 0.02A = 150\Omega$.

We will use three 150-ohm, 1/4W resistors (one for each branch).

Calculating Total Current Draw:

$I_{total} = 20mA + 20mA + 20mA = 60mA$.

Microcontroller Limit Check: The Espressif ESP32 datasheet specifies a maximum continuous GPIO source/sink current of roughly 40mA absolute max, with 20mA recommended for stable logic levels. Driving a 60mA parallel array directly from a single GPIO pin will cause a brownout, degrade the silicon, or fry the pin.

The Fix: Transistor Switching

To safely drive our parallel circuit, we use the ESP32 GPIO to switch a 2N2222 NPN transistor. The 5V rail powers the LED array through the transistor's Collector-Emitter path, while the GPIO only provides the tiny base current needed to turn the transistor on.

Base Resistor Calculation:

We need the 2N2222 to handle 60mA. Assuming a conservative DC current gain ($h_{FE}$) of 100, we need $0.6mA$ of base current. We'll overdrive it slightly with $5mA$ to ensure it saturates fully as a switch.

$R_{base} = (V_{GPIO} - V_{BE}) / I_{base}$

$R_{base} = (3.3V - 0.7V) / 0.005A = 520\Omega$.

We select the nearest standard E12 value: 510 ohms.

Breadboard Verification & Troubleshooting Steps

Never apply power to a newly wired parallel network without verifying it first. A single misplaced jumper can short the 5V rail to ground. Follow this exact sequence with your digital multimeter (DMM).

  1. Cold Continuity Check (Power OFF): Set your DMM to continuity mode. Place the black probe on the ground rail and the red probe on the 5V rail. It should read 'OL' (Open Loop). If it beeps, you have a dead short. Trace your wiring before proceeding.
  2. Verify Base Resistance: Measure the resistance across the 510-ohm base resistor while it is in-circuit. It should read close to $510\Omega$. If it reads significantly lower, the GPIO pin or transistor junction might be shorted.
  3. Hot Voltage Check (Power ON): Apply 5V to the rail. Set the DMM to DC Volts. Measure from the anode of each LED to ground. You should read exactly 5.0V ($\pm 0.1V$). If one branch reads 0V, you have a bad breadboard contact or a broken jumper.
  4. Branch Current Verification: Set the DMM to DC Amps (mA range). To measure a parallel branch, you must break the circuit. Pull the anode leg of one LED out of the breadboard. Place the red DMM probe on the 5V rail and the black probe on the LED anode leg. It should read ~20mA. Repeat for the other branches to ensure current is sharing properly.
  5. Logic Trigger Test: Send a HIGH signal from the ESP32 GPIO. The LEDs should illuminate instantly. Measure the voltage at the Collector of the 2N2222; it should drop to near 0V (typically $0.2V$, the saturation voltage $V_{CE(sat)}$), confirming the transistor is fully switched on.

By understanding the node behavior, respecting the voltage headroom limits of series strings, and managing the cumulative current draw of parallel branches, you can design indicator networks and sensor arrays that are both electrically robust and microcontroller-safe.