In electronics and control theory, an open system (open-loop) executes a command without verifying the result, whereas a closed system (closed-loop) uses sensor feedback to continuously measure and correct its output to match a target setpoint. If you are searching for what is open and closed system in the context of embedded design or motor control, you are looking at feedback architectures. However, beginners frequently confuse these control topologies with basic circuit continuity (open vs. closed circuits) or power transfer mechanics (open vs. closed transition switches). This guide clarifies the terminology and breaks down exactly what changes in your microcontroller code, component cost, and physical wiring when you upgrade from an open to a closed architecture.

The Core Difference: Open-Loop vs. Closed-Loop Systems

An open-loop system assumes the environment is perfectly predictable. You send a signal, and you trust the actuator did what it was told. A closed-loop system assumes the environment is chaotic (friction, temperature drift, mechanical load) and requires a sensor to report back the actual state so the controller can calculate an error value and adjust. According to National Instruments' foundational guide on PID control theory, closing the loop is what allows systems to reject external disturbances and maintain precision.

Bench Reality Check: Moving from open to closed loop doesn't just change your code; it changes your hardware BOM. You must add a sensor (encoder, thermistor, shunt resistor), wire it back to the microcontroller's ADC or interrupt pins, and implement math (like a PID algorithm) to process the error.
Design Parameter Open-Loop System Closed-Loop System
Feedback Path None (Blind execution) Active (Sensor to controller)
Component Cost Low (Actuator + Driver only) High (+ Sensor, ADC, shielding)
MCU Overhead Minimal (Simple PWM output) Heavy (Interrupts, PID math, filtering)
Error Correction Zero (Fails silently under load) Continuous (Adjusts to reject disturbances)
Stability Risk Highly stable (Cannot oscillate) Can oscillate if PID tuning is poor

Worked Numeric Example: Driving a 12V Conveyor Motor

To see what this changes in a real circuit, let’s look at a 12V DC brushed motor driving a small conveyor belt. Our target speed is 3,000 RPM.

The Open-Loop Scenario

You wire the motor to an L298N H-bridge driver controlled by an Arduino Uno. Based on bench testing with no load, you know that an 80% PWM duty cycle (yielding roughly 9.6V at the motor terminals) spins the motor at 2,800 RPM. You hardcode analogWrite(motorPin, 204); into your sketch.

The Failure: You place a 2kg mechanical load on the conveyor. The motor bogs down to 1,900 RPM. Because the Arduino has no feedback path, it continues outputting 80% PWM. The system is now operating with a massive 1,100 RPM error, and the microcontroller is completely blind to the failure.

The Closed-Loop Scenario

You upgrade the system by attaching a 600 PPR (pulses per revolution) quadrature encoder to the motor shaft. You wire the encoder's A and B channels to the Arduino's hardware interrupt pins (D2 and D3).

In your code, you implement a PID (Proportional-Integral-Derivative) controller. When the 2kg load is applied and the speed drops to 1,900 RPM, the encoder reports the deficit to the Arduino within milliseconds. The PID algorithm calculates the error, and the integral term begins accumulating. The Arduino automatically ramps the PWM duty cycle from 80% up to 96% (11.5V) to force the motor through the mechanical resistance, restoring the speed to 2,950 RPM.

⚠️ Safety & Tuning Warning: A common bench mistake when building a closed-loop system is forgetting to clamp the integral term in your PID code. If the motor stalls completely, the error remains maxed out, causing "integral windup." When the stall clears, the accumulated math causes the motor to violently overshoot the setpoint, potentially destroying your mechanical linkage or tripping your power supply's overcurrent protection. Always set hard output bounds in your code.

Where You Meet This in Practice

Understanding what is open and closed system architecture is critical when selecting components for modern DIY and professional builds. Here is where these topologies dominate the workbench:

  • 3D Printer Stepper Motors: Standard NEMA 17 stepper motors run open-loop. The mainboard sends step pulses and assumes the motor moved. If the nozzle hits a hardened blob of plastic and the motor skips steps, the printer doesn't know, resulting in a ruined print (layer shift). Closed-loop steppers (like the BigTreeTech S42B or systems using ODrive controllers) have rear-mounted magnetic encoders. If a step is missed, the driver detects the position error and injects extra current to correct it on the fly.
  • Solar Charge Controllers: A basic PWM solar charge controller is essentially an open-loop voltage clamp; it connects the panel to the battery and lets the battery voltage drag down the panel's operating point, wasting potential wattage. An MPPT (Maximum Power Point Tracking) controller is a closed-loop system. It continuously sweeps the panel's V-I curve, measures the power output, and adjusts a buck-converter's duty cycle to lock onto the exact voltage that yields maximum watts.
  • Smart HVAC and Thermostats: Old mercury-switch thermostats used simple hysteresis (bang-bang control). Modern smart thermostats use closed-loop PID algorithms to anticipate thermal mass, firing the furnace before the room actually drops below the setpoint to maintain a flat temperature curve.

Common Confusions: Circuits, Loops, and Transitions

The terminology around "open" and "closed" in electrical work is notoriously overloaded. Here is how to separate control systems from other common phrases you will encounter on the jobsite or in datasheets.

1. Open/Closed System vs. Open/Closed Circuit

Open/Closed Circuit refers to basic electrical continuity. A closed circuit is a complete path where current can flow from the source, through the load, and back. An open circuit is a broken path (like a switched-off light switch or a blown fuse) where current cannot flow. Control systems (open/closed loops) have nothing to do with basic wire continuity; a closed-loop system still requires a physically closed circuit to operate.

2. Open/Closed System vs. Open/Closed Transition (Transfer Switches)

When wiring a backup generator to a home panel via an Automatic Transfer Switch (ATS), you will see the terms Open Transition and Closed Transition.
• Open Transition: The switch breaks the connection to the utility grid completely before making the connection to the generator (Break-Before-Make). This is standard for residential homes to prevent backfeeding the grid.
• Closed Transition: The switch briefly overlaps both the utility and the generator (Make-Before-Break) to prevent a momentary power drop to sensitive loads. This requires complex synchronization and utility approval, and is entirely unrelated to feedback control loops.

3. Open-Loop vs. Open-Drain / Open-Collector

When reading microcontroller datasheets (like the ESP32 or ATmega328P), you will see GPIO pins described as Open-Drain (or Open-Collector for BJTs). This refers to the internal silicon transistor configuration where the pin can pull the line to Ground (GND) but cannot actively drive it High (VCC)—it relies on an external pull-up resistor. This is a hardware output topology used heavily in I2C communication, and has absolutely zero relation to open-loop control theory.

By clearly defining your system boundaries and understanding whether your application can tolerate silent failures (open-loop) or demands active disturbance rejection (closed-loop), you can save hours of debugging and select the right motor drivers and sensors for your next build.