Mastering the Rules of Binary Subtraction for Digital Logic and Microcontrollers

Binary subtraction is the mathematical process of deducting one base-2 number from another using specific bitwise borrowing rules or, more commonly in modern hardware, two's complement addition. When you write int x = a - b; on an ESP32 or Arduino, the microcontroller doesn't actually 'subtract' in the way you learned in grade school; it manipulates logic gates to add a negative. Understanding the rules of binary subtraction is critical for debugging integer underflow, optimizing DSP algorithms, and designing custom FPGA logic.

The Core Rules of Binary Subtraction (Base-2 Borrowing)

At the most fundamental level, base-2 borrowing follows a strict truth table. If you are designing a dedicated half-subtractor or full-subtractor circuit out of discrete 7400-series logic gates, these are the exact rules your silicon must execute.

Worked Numeric Example: Standard Borrowing

Let's subtract 6 from 13. In decimal, this is 13 - 6 = 7. In binary, 13 is 1101 and 6 is 0110.

• Bit 0 (1s place): 1 - 0 = 1. (No borrow)
• Bit 1 (2s place): 0 - 1. We must borrow from Bit 2. Bit 1 becomes 2 (in decimal concept), so 2 - 1 = 1. (Borrow generated)
• Bit 2 (4s place): The original 1 was borrowed from, leaving 0. We need to calculate 0 - 1. We borrow from Bit 3. 2 - 1 = 1. (Borrow generated)
• Bit 3 (8s place): The original 1 was borrowed from, leaving 0. 0 - 0 = 0.

The result is 0111, which is exactly 7 in decimal. While this makes sense on paper, building a cascading borrow chain in hardware creates severe propagation delay. This leads us to how modern silicon actually handles the math.

What People Commonly Confuse: Borrowing vs. Two's Complement

The most common mistake hobbyists and junior firmware engineers make is assuming the CPU uses the borrowing method shown above. In reality, almost all modern Arithmetic Logic Units (ALUs) use two's complement addition to perform subtraction.

To subtract B from A using two's complement, the hardware does three things:

1. Inverts all bits of B (using simple NOT gates).
2. Adds 1 to the inverted B (by asserting the Carry-In pin on the adder).
3. Adds this modified B to A using a standard binary adder.

Worked Example (13 - 6 via Two's Complement):
A = 1101 (13)
B = 0110 (6)
Invert B: 1001
Add 1 to inverted B: 1010 (This is the two's complement representation of -6).
Add A + (-B): 1101 + 1010 = 10111.
Discarding the 5th carry-out bit leaves 0111 (7). No complex borrow-routing required.

Where You Meet This in Practice: ALUs and Microcontrollers

Understanding these rules changes how you evaluate hardware architecture and write bare-metal code. In a real circuit, using two's complement instead of a dedicated subtractor drastically reduces the silicon area and gate count. According to the Espressif ESP32 Technical Reference Manual, the Xtensa LX6 ALU relies on shared adder circuitry for both addition and subtraction, toggling a single control line to invert the B-input bits and set the carry-in high.

When you are programming FPGAs in Verilog or VHDL, you can explicitly instantiate a full-subtractor, but synthesis tools like Xilinx Vivado or Intel Quartus will almost always optimize assign diff = a - b; into an adder with inverted inputs. If you are studying digital logic from the ground up, the Nand2Tetris project provides an excellent framework for building an ALU that switches between addition and subtraction using a single XOR gate array and a control bit.

Debugging Binary Math Errors in Embedded C/C++

Because microcontrollers execute binary subtraction strictly by the bits, ignoring human concepts of 'negative' unless explicitly told otherwise, math errors frequently destroy hardware or crash firmware.

The Unsigned Underflow Hazard

If you subtract a larger number from a smaller number using an unsigned integer type, the ALU doesn't throw an error. It simply wraps around.

uint8_t position_target = 5;
uint8_t position_current = 10;
uint8_t error = position_target - position_current; 
// error is NOT -5. It is 251.

For deeper insights into how these bitwise operations map to C/C++ data types, the All About Circuits digital logic textbook offers comprehensive chapters on binary arithmetic and hardware mapping.