How Microcontrollers Handle Subtracting Binary Numbers: Two's Complement Logic

Subtracting binary numbers is the digital logic process of finding the difference between two base-2 values, typically executed in hardware by adding the two's complement of the subtrahend rather than using direct subtraction. In a real microcontroller like the ESP32 or an ATmega328P, this mathematical trick fundamentally changes the physical silicon layout. Instead of building a separate, transistor-heavy subtractor circuit with complex borrow-chains, the Arithmetic Logic Unit (ALU) simply routes the second number through a bitwise NOT gate, adds 1, and feeds it into the existing adder. This cuts die size, reduces propagation delay, and lowers power consumption.

The Core Mechanism: Why Hardware Uses Addition to Subtract

If you try to build a direct binary subtractor using discrete logic gates (like 74HC series chips), you quickly run into the 'borrow' problem. A full subtractor requires XOR, AND, and OR gates to calculate the difference and the borrow-out bit. When you cascade these into an 8-bit or 32-bit subtractor, the borrow signal must ripple through every single bit sequentially. This ripple-borrow creates propagation delay, limiting the maximum clock speed of your processor.

To bypass this, digital engineers use two's complement arithmetic. By converting the number you want to subtract (the subtrahend) into its negative equivalent, the ALU can just use its high-speed adder circuit. The adder processes all bits simultaneously (or via a fast carry-lookahead tree), and any final carry-out bit is simply discarded.

4-Bit Two's Complement Reference Table

Here is how the hardware maps positive integers to their negative subtrahend equivalents in a 4-bit ALU. This table is critical for understanding overflow limits in small microcontrollers or shift registers.

Worked Numeric Example: 8-Bit Subtraction on the Bench

Let us trace the exact logic the ALU executes when you ask an Arduino to calculate 14 - 5. The microcontroller does not subtract; it adds the two's complement of 5 to 14.

Step 1: Convert to 8-bit binary
Minuend (14): 0000 1110
Subtrahend (5): 0000 0101

Step 2: Generate the Two's Complement of the Subtrahend
First, apply a bitwise NOT (1's complement) to 5:
1111 1010
Next, add 1 to the result:
1111 1010 + 0000 0001 = 1111 1011
This value (1111 1011) is how the hardware represents -5.

Step 3: Add the Minuend and the Negative Subtrahend
The ALU now performs standard binary addition:

  0000 1110  (14)
+ 1111 1011  (-5)
-----------------
1 0000 1001

Step 4: Handle the Carry-Out
The addition produces a 9-bit result with a carry-out of 1 on the far left. In two's complement subtraction, the ALU's status register (like the SREG on an AVR chip) flags this carry, but the math unit discards it. The remaining 8 bits are 0000 1001, which is exactly 9 in decimal.

Where You Meet This in Practice: Embedded Systems and Debugging

You rarely write out two's complement math by hand when coding in C++, but the underlying hardware behavior constantly impacts how you write drivers for sensors and manage data types. According to Cornell University's computer architecture notes, misunderstanding how the ALU stores these negative values is the root cause of countless embedded bugs.

The I2C Sensor Data Trap (MPU6050 / BME280)

When you read raw accelerometer data from an MPU6050 via I2C, the sensor returns a 16-bit two's complement value. If the sensor is tilted slightly backward, it might return a raw value of -250. In binary, this is 1111 1111 0000 0110.

If you accidentally cast this incoming byte array into an unsigned integer (uint16_t) instead of a signed integer (int16_t), the C++ compiler does not change the bits; it just changes how the ALU interprets them. The MCU reads that same binary string as 65286. Your PID control loop will suddenly think the robot is spinning at Mach 3 and aggressively overcorrect. Always use explicitly sized signed types (int8_t, int16_t, int32_t) when parsing raw I2C/SPI sensor payloads.

Sign Extension for Non-Standard ADCs

Another common bench scenario involves high-resolution ADCs like the ADS1115. This chip outputs 16-bit data, but if you configure it for a specific voltage range, you might only be using 12 or 14 bits of the resolution. If a 12-bit signed value is negative, the 12th bit (the sign bit) is 1.

If you drop this 12-bit value directly into a 16-bit int16_t variable, the upper four bits default to 0. The ALU now sees a massive positive number instead of a small negative one. You must manually 'sign-extend' the two's complement value in your code:

int16_t raw_adc = read_12_bit_sensor();
// If the 12th bit (sign bit) is 1, force the upper 4 bits to 1
if (raw_adc & 0x0800) {
    raw_adc |= 0xF000;
}

Common Confusions and Debugging Pitfalls

When makers transition from decimal math to digital logic, a few specific misconceptions lead to flawed circuit designs or buggy firmware. Here is what people commonly confuse with standard two's complement subtraction.

1. Confusing One's Complement with Two's Complement

One's complement is simply a bitwise NOT operation (flipping 0s to 1s and vice versa). Early computers used one's complement for subtraction, but it suffered from a fatal flaw: it has two representations for zero (00000000 for +0 and 11111111 for -0). This required extra logic gates to handle 'negative zero' edge cases. Two's complement solves this by adding 1, resulting in only one zero and an extra negative number at the bottom of the range. Modern ALUs exclusively use two's complement.

2. Confusing Integer Subtraction with Floating-Point (IEEE 754)

Subtracting binary numbers in an integer ALU is entirely different from subtracting floating-point numbers. Floating-point formats (like the 32-bit float in Arduino) use sign-magnitude representation, not two's complement. In sign-magnitude, the most significant bit is just a plus/minus flag, and the remaining bits represent the absolute value. If you try to use bitwise two's complement tricks on a floating-point variable in C++, you will corrupt the exponent and mantissa, resulting in NaN (Not a Number) or garbage data.

3. Assuming the 'Borrow' Works Like Decimal Math

In grade-school decimal math, if you subtract 8 from 2, you 'borrow' 10 from the next column. Beginners often try to write custom binary subtraction algorithms in software using this exact borrow-ripple logic. While this works mathematically, it is incredibly inefficient in software and hardware. Always rely on the compiler's native - operator for integers, which maps directly to the silicon's two's complement adder, executing in a single clock cycle.