Subtracting in Binary: How ALUs Use Two's Complement Math

Subtracting in binary is the process of finding the difference between two base-2 numbers, typically executed in digital circuits by adding the two's complement of the subtrahend to the minuend. When you write a simple A - B operation in C++ for an ESP32 or wire up a 74LS283 4-bit adder on a breadboard, the physical silicon doesn't perform "subtraction" the way you learned in grade school. Understanding this distinction changes how you design logic circuits and debug register overflows, because it dictates that hardware relies entirely on addition logic and bit-inversion to handle negative math, eliminating the need for dedicated subtractor gates.

The Hardware Reality: Why ALUs Don't Actually "Subtract"

If you look at the datasheet for a classic 74LS83A 4-bit binary full adder, you won't find any subtraction pins. Building a dedicated hardware subtractor using Half-Subtractors and Full-Subtractors requires a messy array of XOR, AND, and NOT gates to manage the "borrow" bit cascading through the ranks. This wastes valuable silicon real estate and increases propagation delay.

Instead, Arithmetic Logic Units (ALUs) use a mathematical trick called two's complement. By inverting the bits of the number you want to subtract (the subtrahend) and adding 1, you create its negative equivalent. The ALU then simply routes both numbers through its existing adder circuitry. This means subtracting in binary fundamentally changes circuit architecture: it allows a single, optimized carry-lookahead adder to handle both addition and subtraction, toggling only a single control line to flip the bits and inject a carry-in of 1 when subtraction is requested.

Worked Numeric Example: 8-Bit Two's Complement Math

Let's walk through a concrete bench example. We want to subtract 27 from 85 using standard 8-bit binary registers.

1. Identify the Minuend (85): In 8-bit binary, 85 is 01010101.
2. Identify the Subtrahend (27): In 8-bit binary, 27 is 00011011.
3. Find the One's Complement of 27: Invert every bit (change 0s to 1s and 1s to 0s). 00011011 becomes 11100100.
4. Find the Two's Complement: Add 1 to the one's complement. 11100100 + 1 = 11100101. This binary string now represents -27 in the eyes of the ALU.
5. Add the Minuend and the Two's Complement:

  01010101  (85)
+ 11100101  (-27 in two's complement)
-----------
1 00111010

The ALU generates a 9-bit result. Because we are operating in an 8-bit register, the 9th bit (the carry-out) is simply discarded. The remaining 8 bits are 00111010, which converts back to decimal 58. The math holds up perfectly, and the hardware only had to use an adder to get there.

Where You Meet This in Practice: Microcontroller Status Flags

You meet binary subtraction every time you evaluate conditional statements or read sensor deltas on a microcontroller. When the ALU finishes a subtraction, it updates the Status Register (SREG) to tell the rest of the system what just happened.

According to the ATmega328P datasheet, the ALU updates specific flags during a SUB instruction:

• Carry Flag (C): In AVR subtraction, the Carry flag actually acts as a "Not-Borrow" flag. If a borrow was required (meaning the subtrahend was larger than the minuend in unsigned terms), the C flag is cleared to 0.
• Zero Flag (Z): Set to 1 if the subtraction results in exactly zero (useful for while(count != 0) loops).
• Overflow Flag (V): Set to 1 if the subtraction causes a signed overflow (e.g., subtracting a negative number from a positive number results in a value too large for the signed bit-width).

Understanding these flags is critical when writing bare-metal C or assembly. If you ignore the Carry flag after an 8-bit subtraction, you have no way of knowing if your result wrapped around below zero.

Real-World Scenario Walkthrough: The PID Controller Underflow Bug

Abstract binary math becomes a very physical problem when it controls hardware. Here is a scenario from a recent bench build involving a custom PID temperature controller.

The Setup: An Arduino Nano reading a 10-bit thermistor ADC (values 0-1023) to control a 12V cartridge heater via a MOSFET and PWM. The code calculates the error by subtracting the temperature setpoint from the current ADC reading.

The Numbers: The target setpoint is 300. The current thermistor reading is 280. The code executes: uint16_t error = current_temp - setpoint; (280 - 300).

The Outcome: The moment the heater turns on and the temperature is below the setpoint, the PWM duty cycle instantly spikes to 100%, the MOSFET gets hot, and the system overshoots the target temperature wildly, risking thermal damage to the printed part.

What Went Wrong: This is a classic unsigned binary subtraction underflow. The variable error was declared as a uint16_t (unsigned 16-bit integer). When the ALU subtracted 300 from 280, it correctly generated the two's complement binary result for -20. However, because the variable was unsigned, the C++ compiler interpreted the Most Significant Bit (MSB)—which normally acts as the negative sign bit—as a massive positive value. The binary result 1111111111101100 was read as 65516 in decimal. The PID loop saw an "error" of 65,516 degrees and maxed out the PWM. Changing the variable to a signed int16_t allowed the compiler to recognize the MSB as a sign bit, correctly resolving the value to -20 and driving the heater proportionally.

Common Confusions: Manual Borrows vs. Hardware Carries

When engineers transition from software to hardware design, or from decimal math to binary logic, two major confusions arise regarding subtracting in binary:

Frequently Asked Questions