Binary Two's Complement in Embedded Systems: Decoding Signed Sensor Data

Binary two's complement is a mathematical method for representing signed integers in digital systems where the most significant bit indicates the sign, and negative numbers are formed by inverting all bits of the positive value and adding one. In embedded electronics and digital logic, this isn't just abstract computer science; it is the exact mechanism your microcontroller uses to understand when a motor is drawing current from a battery versus regenerating power back into it.

People commonly confuse two's complement with sign-magnitude representation (where only the most significant bit flips, leaving the remaining bits identical to the positive number) or one's complement (which suffers from the problematic existence of a 'negative zero'). Two's complement elegantly solves these issues by ensuring there is only one representation for zero and allowing standard binary adders to handle subtraction without requiring extra hardware logic gates.

The Core Concept: What Binary Two's Complement Actually Is

To understand the mechanics, you have to look at the bit-level architecture of your microcontroller's registers. In an 8-bit, 16-bit, or 32-bit signed integer, the Most Significant Bit (MSB) acts as the sign flag. If the MSB is 0, the number is positive. If the MSB is 1, the number is negative.

To manually calculate the two's complement of a positive number to find its negative equivalent, you follow a strict two-step process:

1. Invert all bits: Change every 1 to a 0, and every 0 to a 1 (this is the one's complement).
2. Add 1: Add exactly one to the least significant bit (LSB) of the inverted result.

This system fundamentally changes how arithmetic works in hardware. Because of the way the wrap-around occurs at the MSB boundary, a standard binary adder circuit can subtract B from A simply by adding A and the two's complement of B. This saves silicon area and reduces propagation delay in ALUs (Arithmetic Logic Units).

Worked Numeric Example: Decoding a 16-Bit Sensor Register

Let's look at a real-world scenario: reading the Shunt Voltage register (01h) of the Texas Instruments INA219 bidirectional current/power monitor over I2C. This sensor outputs a 16-bit signed integer, and its LSB resolution is programmed to 10 µV.

Scenario A: Positive Current (Discharging)
You measure +10.0 mV across the shunt resistor. Dividing 10.0 mV by the 10 µV LSB gives a decimal value of 1000.

• Decimal: 1000
• Binary: 0000 0011 1110 1000
• Hexadecimal: 0x03E8

Scenario B: Negative Current (Regenerative Braking / Charging)
The current reverses, and you measure -10.0 mV across the shunt. The decimal value is -1000. Let's derive the two's complement binary representation:

1. Start with positive 1000: 0000 0011 1110 1000
2. Invert all bits (One's Complement): 1111 1100 0001 0111
3. Add 1 to the LSB: 1111 1100 0001 1000

The final binary is 1111 1100 0001 1000, which translates to 0xFC18 in hexadecimal. If your ESP32 reads 0xFC18 from the I2C bus and you mistakenly store it in an unsigned int (or uint16_t), the compiler evaluates it as 64,536. Your code will erroneously calculate that the motor is pulling 645 Amps. By casting the raw register data to a signed 16-bit integer (int16_t), the compiler recognizes the MSB as a sign bit and correctly yields -1000.

Where You Meet This in Practice (And What It Changes)

You will encounter two's complement constantly when interfacing with digital sensors via I2C or SPI. Common examples include:

• Accelerometers/Gyros (MPU6050, ICM-20948): Acceleration along the X/Y/Z axes can be positive or negative depending on orientation relative to gravity.
• Precision ADCs (ADS1115, MCP3208): When configured for differential input, the ADC measures the voltage difference between two pins, which can swing negative.
• Current Shunt Monitors (INA219, INA226): Measuring bidirectional current flow for battery management systems (BMS).

Decision Tree: Handling Signed Registers in Embedded C++

A massive pain point for Arduino and ESP32 developers is 'sign extension.' If a sensor outputs 12-bit or 24-bit data, but your microcontroller processes in 16-bit or 32-bit chunks, you cannot simply cast the variable. If the MSB of the sensor's data width is 1, you must manually pad the higher bits with 1s, not 0s. Use the Arduino bitwise operators to execute this decision path:

The C++ Implementation for 12-bit Sign Extension:

int16_t raw_12bit = 0x818; // Raw data from a 12-bit ADC
int16_t signed_val;

// Check if the 12th bit (bit 11, zero-indexed) is set
if (raw_12bit & 0x800) {
  // MSB is 1: Pad the upper 4 bits with 1s to make it a valid 16-bit negative
  signed_val = raw_12bit | 0xF000; 
} else {
  // MSB is 0: It's already a valid positive number
  signed_val = raw_12bit;
}

Component Selection: Native Two's Complement vs. Analog Offset

When designing a bidirectional current measurement circuit (e.g., monitoring a solar charge controller or a motor H-bridge), you must choose between an analog Hall-effect sensor and a digital shunt monitor. This choice dictates whether you rely on the microcontroller's ADC to handle two's complement conversion, or if the sensor handles it natively.

Frequently Asked Questions