Reading Sensor Data in Signed Binary: Avoid Control Loop Failures

Signed binary is a digital numbering system where the most significant bit (MSB) acts as a sign indicator, allowing microcontrollers to process values below zero using Two's Complement arithmetic. If you have ever watched a serial monitor spit out 65535 when a motor reverses or a battery starts charging, you have just collided with the difference between signed and unsigned data types. In physical circuits, the electricity does not care about your variable declarations, but your MCU's ADC (Analog-to-Digital Converter) and I2C registers absolutely do. Misinterpreting signed binary data changes a simple reverse-current reading into a catastrophic control-loop failure, often resulting in blown MOSFETs or tripped breakers.

The Core Mechanism: How Two's Complement Actually Works

Modern microcontrollers do not use a simple "sign bit" attached to a standard positive number (known as Signed Magnitude). Instead, they use Two's Complement. This system was adopted because it allows the ALU (Arithmetic Logic Unit) to use the exact same hardware adder circuits for both addition and subtraction, and it eliminates the problem of having both a "positive zero" and a "negative zero."

In an 8-bit signed system, the MSB (Bit 7) represents -128, while the remaining bits represent positive values up to +127. Let us look at a concrete numeric example to see how a negative number is constructed.

Worked Numeric Example: Finding -5 in 8-Bit

1. Start with the positive binary: +5 in 8-bit binary is 00000101.
2. Invert all bits (One's Complement): Flip every 1 to 0, and every 0 to 1. This gives 11111010.
3. Add 1 (Two's Complement): Add 1 to the inverted number. 11111010 + 00000001 = 11111011.

The result, 11111011, is how the MCU stores -5. Notice that the MSB is 1. In signed binary, an MSB of 1 always dictates a negative value. If you cast this 8-bit variable as an int8_t in C++, the compiler reads the MSB as a sign flag and correctly outputs -5. If you cast it as a uint8_t (unsigned), the compiler treats the MSB as a standard +128 value, resulting in an output of 251.

Where You Meet Signed Binary in Practice

You will rarely need to manually calculate Two's Complement on the bench, but you must know where silicon manufacturers implement it. Signed binary dictates how you declare variables when interfacing with the following hardware:

• Bidirectional Current Sensors: Shunt-based monitors (like the INA219 or ACS712) measure current flowing in both directions. A solar charge controller must know if current is flowing into the battery (positive) or out of the battery (negative).
• Motor Control and Encoders: Quadrature encoders output relative position data. Moving backward generates negative pulse counts. H-bridge motor drivers use signed PWM values to dictate direction and speed simultaneously.
• Digital Audio and DSP: I2S MEMS microphones output AC audio waveforms centered around a zero-crossing. The raw data streams as 24-bit or 32-bit signed integers to accommodate the negative half of the sine wave.
• Temperature Sensors: Digital sensors like the DS18B20 use signed 16-bit registers to report sub-zero Celsius temperatures.

Bench Scenario: The Bidirectional Current Sensor Trap

To understand what this changes in a real installation, let us walk through a common bench failure involving an ESP32 and a Texas Instruments INA219 current shunt monitor.

The Setup

You are building a 12V battery monitor for a solar setup. You wire a 0.1-ohm shunt resistor to the INA219, which communicates with the ESP32 via I2C. The system needs to log both charging current (positive) and discharge current (negative).

The Numbers

The INA219 Current Register is a 16-bit signed integer. According to the INA219 datasheet, the LSB (Least Significant Bit) is programmed to 1mA.
At 0 Amps, the register reads 0x0000 (Decimal 0).
At +10 Amps, the register reads 0x2710 (Decimal 10,000).
At -5 Amps (discharging), the register outputs 0xEC78 (Decimal -5,000 in Two's Complement).

The Outcome

In your Arduino IDE code, you read the two I2C bytes and combine them using bitwise shifts:

uint16_t raw_current = (msb << 8) | lsb;
float amps = raw_current * 0.001;

When the battery discharges at -5A, the serial monitor prints 60.536 Amps instead of -5.0 Amps. Your code's overcurrent protection sees 60A, assumes a dead short, and immediately opens the main relay, killing power to the cabin.

What Went Wrong

The variable was declared as uint16_t (unsigned). The hex value 0xEC78 translates to 60,536 in unsigned decimal. The MCU stripped the sign context. The fix requires exactly one word change in the variable declaration:

int16_t raw_current = (msb << 8) | lsb; // Signed 16-bit integer

By using int16_t, the C++ compiler recognizes the MSB as a sign flag, correctly interpreting 0xEC78 as -5,000. The math resolves to -5.0 Amps, and the control loop operates normally.

Memory Allocation: Signed vs. Unsigned Reference Matrix

When writing firmware for AVRs, ESP32s, or STM32s, always select the data type based on the sensor's datasheet register map. Use this matrix to verify your variable boundaries.

FAQ: Debugging Signed Binary Errors on the Bench

uint32_t raw = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
int32_t signed_value = (int32_t)raw;