Understanding Binary 2s Complement in Embedded Systems and Microcontrollers

Binary 2s complement is a mathematical method used by digital systems to represent signed integers, where the most significant bit (MSB) acts as a negative weight rather than a simple sign flag. If you are reading raw sensor data over I2C, parsing motor encoder ticks, or debugging a C++ sketch on an ESP32, misunderstanding this concept will result in wildly incorrect readings—like a temperature sensor reporting +65,000°C instead of -4°C, or a PID motor controller driving a servo at 100% power in the wrong direction because it misread a negative position error as a massive positive one.

The 8-Bit Signed Integer Reference Matrix

To understand how microcontrollers map binary states to negative numbers, we have to look at the weight of each bit. In an 8-bit unsigned system, the bits represent weights of 128, 64, 32, 16, 8, 4, 2, and 1. In binary 2s complement, the MSB (bit 7) flips its weight to -128. This single architectural choice allows the ALU (Arithmetic Logic Unit) to use the exact same addition circuitry for both positive and negative numbers.

Worked Numeric Example: Converting and Casting

Let us walk through two scenarios you will encounter on the workbench: manually converting a negative decimal to binary, and decoding a raw hex byte read from an I2C sensor register.

Scenario A: Converting -42 to 8-Bit Binary

1. Start with the positive absolute value: +42 in binary is 0010 1010.
2. Invert all bits (1s complement): Change every 0 to 1, and every 1 to 0. This yields 1101 0101.
3. Add 1 to the result: 1101 0101 + 0000 0001 = 1101 0110.
4. Verify the weight: The MSB is 1, so we start with -128. The remaining bits (64, 16, 4, 2) sum to 86. -128 + 86 = -42. The hex equivalent is 0xD6.

Scenario B: Decoding 0xE4 from an I2C Register

Suppose your logic analyzer shows an I2C temperature sensor returning 0xE4 for the current reading. How do you find the decimal value?

1. Check the MSB: 0xE4 is 1110 0100 in binary. The MSB is 1, meaning this is a negative number.
2. Invert the bits: 1110 0100 becomes 0001 1011.
3. Add 1: 0001 1011 + 0000 0001 = 0001 1100.
4. Convert to decimal: 0001 1100 is 16 + 8 + 4 = 28. Apply the negative sign: -28.

Where You Meet This in Practice

Understanding binary 2s complement changes how you write firmware and wire digital buses in real installations. It dictates how raw electrical signals are translated into physical world measurements.

I2C and SPI Sensor Data (Accelerometers & Gyroscopes)

When wiring an MPU6050 IMU to a microcontroller, the X, Y, and Z acceleration axes are stored across two 8-bit registers (High and Low) forming a 16-bit word. If the sensor is tilted slightly backward, the Z-axis might output a negative value. If you read those two bytes and combine them into an unsigned int, a reading of -500 (binary 1111 1110 0000 1100) will be interpreted as 65,036. Your tilt-compensation algorithm will instantly fail. You must cast the combined 16-bit register read to an int16_t to preserve the 2s complement sign.

Quadrature Encoders and Motor Control

In closed-loop DC motor control, quadrature encoders track position. If your motor spins in reverse, the encoder counter must decrement. Microcontroller hardware encoder peripherals (like the PCNT on the ESP32) use signed 32-bit integers to track this. If you attempt to calculate the error between your target position and current position using unsigned math, crossing the zero-boundary will result in a massive integer underflow, causing your PID controller to apply maximum PWM voltage in the wrong direction, potentially stripping gears or burning out the H-bridge MOSFETs.

Common Confusions and Edge Cases

Even experienced makers trip over the edge cases inherent to 2s complement math. Here is what people commonly confuse it with, and where the system breaks down.

Sign-Magnitude vs. 2s Complement

Humans naturally think in sign-magnitude: a plus or minus sign followed by the absolute value (e.g., -5 is just 5 with a minus flag). Early computers tried this, but it resulted in two zeros (+0 and -0) and required complex, separate subtraction circuitry. 2s complement eliminates negative zero entirely. If you invert all bits of 0 (0000 0000) and add 1, the 9th bit overflows and is discarded, leaving you right back at 0000 0000.

The Odometer Analogy: Overflow and Underflow

Think of an 8-bit signed integer like a mechanical car odometer that only goes up to 999,999. If you are at 999,999 and drive one more mile, the gears roll over to 000,000. In binary 2s complement, if you add 1 to the maximum positive value of +127 (0111 1111), the binary addition results in 1000 0000. Because the MSB is now 1, the system instantly interprets this as -128. This is known as signed overflow, and it is the exact mechanism behind the infamous Y2K38 bug in 32-bit Unix time systems.

Floating-Point Numbers Do Not Use 2s Complement

A frequent mistake is assuming 2s complement applies to float or double variables. It does not. Floating-point numbers use the IEEE 754 standard, which relies on a dedicated sign bit (sign-magnitude) alongside an exponent and mantissa. If you attempt to bitwise-shift a float to divide it by two, you will corrupt the exponent and destroy the value. Bitwise 2s complement tricks only apply to fixed-point signed integers.