The Binary Value of a Negative Number: Two's Complement in Embedded C

The binary value of a negative number in modern microcontrollers is represented using Two's Complement, a system where the most significant bit carries a negative mathematical weight rather than acting as a simple sign flag, allowing standard binary addition circuits to handle subtraction seamlessly. This representation fundamentally changes how hardware registers interpret sensor data and control signals; feeding a signed negative value into an unsigned hardware register causes an integer wraparound that can pin outputs high and destroy connected components. Beginners commonly confuse Two's Complement with "sign-magnitude" representation—the system where the MSB is just a plus/minus sign and the remaining bits are the absolute value—which is how humans write "-5" on paper, but not how Arithmetic Logic Units (ALUs) process math in silicon.

The Math: Calculating the Binary Value of a Negative Number

To understand what happens on the bench, you need to see the exact bit-level translation. Microcontrollers do not store a minus sign. They use Two's Complement. Let's calculate the 8-bit binary value of -10.

1. Start with the positive binary equivalent: Positive 10 in 8-bit binary is 0000 1010.
2. Invert all bits (One's Complement): Flip every 1 to 0, and every 0 to 1. This yields 1111 0101.
3. Add 1 to the result: 1111 0101 + 0000 0001 = 1111 0110.

The binary value of -10 is 1111 0110. Notice the Most Significant Bit (MSB) is 1. In Two's Complement, the MSB doesn't just mean "negative"; it holds a negative place value. For an 8-bit number, the MSB represents -128. If we read 1111 0110 as an unsigned integer, the math is: 128 + 64 + 32 + 16 + 4 + 2 = 246. This dual-identity is the root cause of most embedded C bugs involving negative numbers.

For a deeper look at the ALU logic gates that make this possible, the All About Circuits guide on Two's Complement provides an excellent schematic breakdown of the adder circuits involved.

Where You Meet This in Practice

You will rarely write Two's Complement by hand, but you will battle its side effects constantly in embedded systems. Here is where the binary value of a negative number dictates circuit behavior:

• I2C Sensor Data (e.g., MPU6050 Accelerometers): When an accelerometer tilts backward, it returns a negative signed 16-bit integer. The I2C bus transmits this as two 8-bit registers (MSB and LSB). If you read these into standard unsigned bytes and stitch them together without casting to a signed 16-bit integer (int16_t), your code will think the sensor is reading a massive positive G-force.
• Rotary Encoders: Quadrature encoders track relative position. Turning the shaft counter-clockwise decrements the counter. If your counter variable is an unsigned 8-bit integer (uint8_t), turning it one click backward from 0 doesn't yield -1; it wraps around to 255, causing your menu system or motor position loop to jump to the opposite extreme.
• PID Control Loops: The "Error" term in a PID controller is Setpoint - Actual. If the motor overshoots the target, the error becomes negative. The microcontroller must process this negative binary value to apply reverse braking or reduce the PWM duty cycle.

Bench War Story: When a Negative PWM Value Fries a Motor Driver

Theory is clean; the workbench is unforgiving. Here is a real-world scenario demonstrating what happens when the binary value of a negative number meets an unsigned hardware register.

The Numbers: The target speed is 512 (50%). A sudden mechanical load drops the actual speed to 400. The error term calculates as 512 - 400 = +112. The code adds this to the baseline, and the motor recovers. However, when the load is suddenly removed, the motor spins up to 600. The error term is now 512 - 600 = -88.

The Outcome: The developer passes the error-adjusted variable directly into the Espressif LEDC API via ledc_set_duty(LEDC_LOW_SPEED_MODE, channel, new_duty). The variable holding the new duty cycle is a standard 32-bit signed integer (int), and its value is -88.

What Went Wrong: The LEDC hardware register expects an unsigned 10-bit integer. In 32-bit Two's Complement, -88 is represented as 11111111 11111111 11111111 10101000. When the ESP32's hardware peripheral truncates this to the 10 bits it actually uses for duty cycle resolution, it takes the 10 least significant bits: 11 10101000. In unsigned decimal, 1110101000 is 936.

Instead of reducing the duty cycle to slow the motor down, the microcontroller commanded a 936/1023 (91.5%) duty cycle. The motor violently surged to maximum speed, the DRV8833 driver chip overheated due to the sudden current spike, and the thermal shutdown pin tripped, crashing the system. The fix? Clamping the variable to a minimum of 0 before passing it to the hardware register.

How to Safely Handle Signed Data in Microcontrollers

To prevent Two's Complement wraparound from destroying your circuit or logic, follow these numbered steps when dealing with sensor data and control loops:

1. Use Explicitly Sized Signed Types: Never use generic int for hardware-mapped data. Use int8_t, int16_t, or int32_t from <stdint.h>. This guarantees the compiler knows exactly where the sign bit lives.
2. Cast I2C/SPI Register Pairs Correctly: When stitching an MSB and LSB from a sensor into a 16-bit value, use this exact bitwise pattern:
   int16_t val = (int16_t)((msb << 8) | lsb);
   The cast to int16_t at the very end forces the compiler to recognize the 16th bit as a negative weight, properly sign-extending it if you later promote it to a 32-bit float for math.
3. Clamp Before Casting to Unsigned: Before sending any calculated variable to a PWM, DAC, or servo library, clamp it.
   if (duty < 0) duty = 0;
if (duty > MAX_DUTY) duty = MAX_DUTY;
4. Use Modular Arithmetic for Encoders: If you are tracking a rotary encoder that wraps around a 360-degree circle, use the modulo operator (%) rather than relying on unsigned integer overflow, which is technically undefined behavior in standard C (though defined in microcontroller hardware).

Frequently Asked Questions