Signed binary conversion is the method of representing both positive and negative integers in base-2 digital systems, most commonly using the two's complement format where the most significant bit indicates the sign. In practical embedded systems, this mathematical convention dictates exactly how your microcontroller interprets bidirectional physical measurements from external hardware. If you misinterpret a signed 16-bit register as unsigned, a -10°C temperature reading transforms into 65526, instantly causing catastrophic failures in your PID control loops or battery management logic. Beginners commonly confuse two's complement with sign-magnitude representation—where you simply flip the most significant bit (MSB) to 1 to denote a negative number—which is how humans intuitively write '-5' on paper, but is entirely incompatible with how hardware Arithmetic Logic Units (ALUs) process addition and subtraction.
The Core Mechanism: How Two's Complement Actually Works
To understand signed binary conversion, you have to look at it from the perspective of silicon efficiency. Hardware designers use two's complement because it allows the ALU to use the exact same addition circuitry for both positive and negative numbers, eliminating the need for separate subtraction hardware.
Let's walk through a worked numeric example to see the exact bitwise mechanics. We will convert -13 into an 8-bit signed binary value:
- Start with the positive binary equivalent: Positive 13 in 8-bit binary is
0000 1101. - Invert all the bits (One's Complement): Flip every 1 to 0 and every 0 to 1. This yields
1111 0010. - Add 1 to the result (Two's Complement):
1111 0010+0000 0001=1111 0011.
The resulting binary 1111 0011 (or 0xF3 in hex) is how the microcontroller stores -13. To verify this mathematically, we apply the positional weight rule where the MSB carries a negative weight. In an 8-bit system, the MSB (bit 7) represents -128, while bits 6 through 0 represent +64, +32, +16, +8, +4, +2, and +1.
Calculating the value of 1111 0011:
(-128) + 64 + 32 + 16 + 0 + 0 + 2 + 1 = -13.
8-bit signed integer (int8_t): -128 to +127
16-bit signed integer (int16_t): -32,768 to +32,767
32-bit signed integer (int32_t): -2,147,483,648 to +2,147,483,647
Where You Meet Signed Binary in Practical Electronics
You will encounter signed binary conversion constantly when writing drivers for I2C and SPI sensors that measure bidirectional physical phenomena. Here are two specific bench scenarios where getting this wrong yields baffling telemetry data.
Scenario 1: High-Precision Temperature Sensors (e.g., TI TMP117)
The Texas Instruments TMP117 is a staple for precision thermal monitoring. Its temperature register is a 16-bit signed integer. According to the TI TMP117 datasheet, the resolution is 0.0078°C per LSB. If the sensor reads 0x7FFF, the temperature is +255.99°C. However, if the environment drops below freezing and the sensor outputs 0x9B40, you are looking at a negative temperature. If your C++ code stores this in a uint16_t variable, 0x9B40 evaluates to 39,744. Your code will think the sensor is on fire rather than sitting at -20°C.
Scenario 2: Bidirectional Current Shunt Monitors (e.g., INA219)
When building a battery management system (BMS) or a solar charge controller, you need to know if current is flowing into the battery (charging) or out of the battery (discharging). The INA219 current register outputs a 16-bit signed two's complement value. A positive hex value indicates discharge, while a negative two's complement hex value (where the MSB is 1) indicates charge current. Failing to cast this register correctly means your BMS will interpret a 5A charging current as a massive 65,531A discharge fault, triggering a false shutdown.
Never use
uint16_t or unsigned int to store raw I2C register bytes if the datasheet specifies a signed output. The moment the MSB crosses into the high byte, the unsigned variable will overflow into the positive tens-of-thousands range. Always cast the combined raw bytes to an int16_t immediately upon reading.
Debugging Signed vs. Unsigned Register Reads
When debugging a new sensor breakout board on your workbench, it helps to map out the hex boundaries. The table below illustrates how the exact same 16-bit binary sequence is interpreted differently depending on your variable type in C/C++.
| Hex Value | Binary (16-bit) | Unsigned (uint16_t) | Signed (int16_t) | Physical Meaning |
|---|---|---|---|---|
| 0x000A | 0000 0000 0000 1010 | 10 | 10 | Positive measurement |
| 0x7FFF | 0111 1111 1111 1111 | 32,767 | 32,767 | Maximum positive limit |
| 0x8000 | 1000 0000 0000 0000 | 32,768 | -32,768 | Maximum negative limit |
| 0xFFFF | 1111 1111 1111 1111 | 65,535 | -1 | Negative one |
Here is the exact C++ pattern you should use in your Arduino or ESP32 sketch to safely perform signed binary conversion when reading two bytes from an I2C bus:
// Read two bytes from the I2C sensor
uint8_t msb = Wire.read(); // Most Significant Byte
uint8_t lsb = Wire.read(); // Least Significant Byte
// Combine into a 16-bit unsigned integer first
uint16_t raw_unsigned = (msb << 8) | lsb;
// CRITICAL: Cast to signed 16-bit integer to trigger two's complement interpretation
int16_t signed_value = (int16_t)raw_unsigned;
// Now apply the sensor's LSB scaling factor
float final_measurement = signed_value * 0.0078; // Example for TMP117Signed Binary Conversion FAQ
Why does my Arduino print 65535 when the sensor reads -1?
This happens because your variable is declared as an unsigned 16-bit integer (uint16_t). In two's complement, -1 is represented by all bits being high (1111 1111 1111 1111 or 0xFFFF). An unsigned variable has no concept of negative weights; it simply adds up all the positional values (32768 + 16384 + ... + 1), resulting in 65,535. Change your variable declaration to int16_t to force the compiler to apply signed binary conversion rules.
How do I manually convert a 32-bit signed hex value to decimal?
First, check the MSB (bit 31). If the hex value is below 0x80000000, the MSB is 0, meaning it is a positive number; simply convert it using standard base-16 to base-10 math. If the hex value is 0x80000000 or higher, the MSB is 1, indicating a negative number. To find the decimal value manually, invert all 32 bits, add 1 to the result, convert that new positive hex number to decimal, and then apply a negative sign to your final answer.
What is the difference between sign-magnitude and two's complement?
Sign-magnitude is the human-readable format where the MSB acts purely as a positive/negative flag, and the remaining bits represent the absolute value (e.g., 1000 0101 is -5). Two's complement is the hardware format where the MSB carries a negative mathematical weight (-128 in 8-bit). Hardware engineers universally use two's complement because it allows the ALU to add positive and negative numbers using a single, simple binary adder circuit without needing conditional logic to check the sign bit first.
Can I use signed binary conversion for floating-point sensor data?
No. Signed binary conversion via two's complement applies strictly to integers. If your sensor outputs floating-point data (like a 32-bit float for a GPS coordinate or a complex impedance measurement), it uses the IEEE 754 standard. IEEE 754 divides the 32 bits into a sign bit, an 8-bit exponent, and a 23-bit mantissa. You cannot cast an IEEE 754 hex payload directly into an int32_t and expect a valid number; you must cast the raw bytes into a float type using a pointer cast or a union in C++.
