How Microcontrollers Handle Negative Binary Numbers in Signed Math

Negative binary numbers are a method of representing values below zero in digital systems, most commonly using the two's complement format where the most significant bit (MSB) acts as a negative mathematical weight rather than a simple minus sign. In real-world circuits, this representation dictates how microcontrollers like the ESP32 or STM32 process signed integers, directly affecting how you configure analog-to-digital converters (ADCs) for bipolar signals or interpret feedback from quadrature encoders. The most common point of confusion is treating the MSB as a standalone polarity flag (sign-magnitude) instead of an integrated part of the base-2 math, which leads to catastrophic off-by-one errors and overflow bugs in embedded C code.

Decoding the Formats: Two's Complement vs. The Rest

Before modern ALUs (Arithmetic Logic Units) standardized on two's complement, early computing systems experimented with multiple ways to represent values below zero. Understanding why two's complement won requires looking at the hardware reality of addition circuits. If a processor uses sign-magnitude, it requires separate, complex logic paths for addition and subtraction. Two's complement allows the ALU to use the exact same adder circuitry for both positive and negative numbers, ignoring the final carry-out bit to arrive at the correct signed result.

When you read a datasheet for a digital sensor or configure a variable in C, you are almost always dealing with two's complement. Here is how the three primary 8-bit representation methods map to real decimal values.

Worked Numeric Example: Signed Math on the Bench

Let's prove that two's complement allows standard binary addition to work seamlessly with negative numbers by adding +55 and -42 using 8-bit registers. The mathematical answer should be +13.

Step 1: Convert +55 to 8-bit binary.
55 in standard binary is 00110111.

Step 2: Convert -42 to 8-bit two's complement.
First, write positive 42 in binary: 00101010.
Next, invert all the bits (one's complement): 11010101.
Finally, add 1 to the result: 11010101 + 00000001 = 11010110.
So, -42 is 11010110.

Step 3: Add them together using standard binary addition.

  00110111  (+55)
+ 11010110  (-42)
-----------
1 00001101

The ALU generates a 9-bit result with a carry-out of 1. In two's complement math, we simply discard the carry-out bit. The remaining 8 bits are 00001101, which converts exactly to decimal +13. The hardware didn't need to know it was performing subtraction; it just added the bits.

Where You Meet Negative Binary Numbers in Practice

You might think binary math is strictly a software problem, but it physically manifests in how you wire and configure sensors on the bench. If you misunderstand signed data types, your hardware will yield nonsensical readings.

Bipolar ADC Measurements and Current Sensors

When measuring AC waveforms or bidirectional DC current, the signal swings above and below a reference midpoint. Take the popular INA219 I2C current/power monitor or the ACS712 Hall-effect current sensor. These output bipolar data. The ACS712 outputs a 2.5V offset at 0A, meaning 1A might be 3.0V and -1A might be 2.0V. When your microcontroller's 12-bit ADC reads this, a reading below the 2.5V midpoint (e.g., 1.2V) represents negative current. If you store this ADC reading in an unsigned int, a negative current value will wrap around and display as a massive positive number (e.g., 4090 instead of -6). You must cast the ADC buffer to a signed int (or int16_t) to allow the two's complement math to resolve the negative voltage delta correctly.

Quadrature Encoders in Motor Control

In CNC routers or robotic arms, rotary encoders track position. When you home the axis, you set the current position to zero. As the motor reverses past the home switch, the position becomes negative. Microcontrollers handling interrupt-driven encoder counts must use signed 32-bit integers (int32_t). If an unsigned variable is used, a single step backward from zero results in a position reading of 4,294,967,295, causing the motion controller to violently overcorrect.

I2S Digital Audio and DSP

Digital MEMS microphones (like the ICS-43434) output audio data over I2S using 24-bit or 32-bit two's complement words. Audio waveforms are inherently AC, oscillating around a zero-crossing. Digital Signal Processing (DSP) filters rely entirely on the MSB acting as a negative weight to calculate moving averages and FIR filters without introducing DC offset errors.

Embedded C Gotchas and Debugging Signed Math

Even when you correctly define a variable as signed, the C compiler can introduce subtle bugs if you aren't careful with bitwise operations. According to standard C arithmetic type definitions, the behavior of certain operators changes drastically based on the sign bit.

• Right-Shifting (Arithmetic vs. Logical): If you right-shift an unsigned integer (>>), the compiler performs a logical shift, filling the leftmost bits with zeros. If you right-shift a signed negative integer, the compiler performs an arithmetic shift, filling the leftmost bits with ones to preserve the negative sign. If you accidentally use an unsigned type for a negative sensor reading and shift it to scale the value, you will destroy the sign bit and corrupt the data.
• Integer Overflow on Multiplication: Multiplying two 16-bit signed integers can easily exceed the +32,767 limit of an int16_t. For example, multiplying -200 by -200 yields +40,000, which overflows a 16-bit signed register and wraps into a negative number. Always cast to a 32-bit signed integer (int32_t) before performing multiplication on 16-bit sensor data.
• The -128 Edge Case: In 8-bit two's complement, the range is -128 to +127. If your code attempts to negate -128 (e.g., int8_t val = -128; val = -val;), it overflows because +128 cannot be represented in 8 bits. The value will remain -128, creating an infinite loop in absolute-value calculations.