char), -42 is 11010110. In 16-bit (Arduino int), it is 11111111 11010110. In 32-bit (ESP32/ARM int), it is 11111111 11111111 11111111 11010110.
The governing formula for negative numbers in Two's Complement is 2^N - |X|, where N is the bit-width and X is the absolute decimal value. For our 8-bit example: 2^8 - |-42| = 256 - 42 = 214. Converting the positive integer 214 to standard binary yields 11010110. Unlike AC power calculations where voltage and phase dictate the outcome, digital logic conversions are fixed by memory allocation boundaries.
| Architecture | C++ Data Type | Bit-Width (N) | Valid Range | Binary Representation of -42 | Hex Equivalent |
|---|---|---|---|---|---|
| 8-bit AVR (Arduino Uno) | int8_t / char |
8 | -128 to +127 | 11010110 |
0xD6 |
16-bit DSP / AVR int |
int16_t / int |
16 | -32,768 to +32,767 | 11111111 11010110 |
0xFFD6 |
| 32-bit ARM (ESP32, STM32) | int32_t / int |
32 | -2.14B to +2.14B | 1111...1111 11010110 |
0xFFFFFFD6 |
| 64-bit Desktop (x86_64) | int64_t / long |
64 | ±9.22 Quintillion | 1111...1111 11010110 |
0xFFFFFFFFFFFFFFD6 |
The Assumption That Fixes Your Answer: Word Size and Encoding
Asking 'what is -42 in signed binary' without specifying a bit-width is like asking 'what size breaker do I need' without stating the load. The answer is physically meaningless until you define the memory container. The assumption that fixes your answer is twofold: the word size (8, 16, 32, or 64 bits) and the encoding scheme.
While Sign-Magnitude and One's Complement exist in legacy computer science theory, Two's Complement is the undisputed standard for modern embedded C/C++ development. It is the native format for the ATmega328P inside the Arduino Uno and the Xtensa LX6 cores inside the ESP32-WROOM-32. Two's Complement is preferred because it provides a single representation for zero and allows the ALU (Arithmetic Logic Unit) to use the exact same addition circuitry for both positive and negative numbers.
When you declare int8_t sensor_offset = -42; in your firmware, the compiler automatically applies the Two's Complement formula based on the 8-bit boundary. If you attempt to read this memory address via a logic analyzer or an SPI debug register, you will see 0xD6 on the bus. The most significant bit (MSB) acts as the sign bit; because it is a 1, the hardware interprets the value as negative.
How the Conversion Shifts Across Microcontroller Architectures
Just as a 120V appliance draws different current than a 230V appliance for the same wattage, a negative integer shifts its binary footprint depending on the register width it occupies. When you port code from an 8-bit Arduino Nano to a 32-bit ESP32, the underlying binary representation of your constants expands via sign extension.
Sign extension dictates that when moving a signed variable to a wider register, the MSB (the sign bit) is copied into all the new higher-order bits. This preserves the decimal value. If the compiler simply padded with zeros (e.g., turning 8-bit 11010110 into 16-bit 00000000 11010110), the hardware would read it as positive 214, instantly breaking your control logic.
Below is a table of neighboring values within a ±20% range of our target (-42), demonstrating how the bit patterns shift incrementally in an 8-bit register. Notice how the MSB remains firmly anchored at 1 to maintain the negative polarity.
| Decimal Value | 8-Bit Signed Binary (Two's Complement) | Hex Byte | Delta from -42 |
|---|---|---|---|
| -34 | 1101 1110 |
0xDE |
+8 |
| -38 | 1101 1010 |
0xDA |
+4 |
| -42 | 1101 0110 |
0xD6 |
0 (Target) |
| -46 | 1101 0010 |
0xD2 |
-4 |
| -50 | 1100 1110 |
0xCE |
-8 |
When Signed Binary Conversion Becomes Meaningless
There are two specific scenarios on the workbench where attempting to convert a decimal to signed binary yields garbage data or compiler warnings. Recognizing these edge cases prevents hours of debugging serial output.
1. Integer Overflow (Exceeding the Bit-Width Limit)
The conversion is meaningless if the absolute value exceeds the maximum capacity of the chosen signed container. An 8-bit signed integer (int8_t) has a hard mathematical ceiling of +127 and a floor of -128. If you attempt to convert -130 into 8-bit signed binary, you trigger an overflow. In C++, this results in undefined behavior or a wrap-around (yielding +126). To safely store -130, you must step up to a 16-bit container (int16_t), which shifts the formula to 2^16 - 130 = 65406 (11111111 01111110).
2. Floating-Point Numbers Without IEEE 754 Context
If your sensor outputs -42.5, asking for the 'signed binary' of this number is meaningless unless you explicitly invoke the IEEE 754 floating-point standard. Two's Complement only applies to integers. To represent -42.5 in a 32-bit ESP32 memory register, the hardware encodes the sign bit, an 8-bit exponent, and a 23-bit mantissa. The resulting 32-bit binary string is 11000010 00101001 00000000 00000000 (0xC2290000). Applying the standard integer Two's Complement formula to a decimal fraction will yield completely invalid machine code.
Frequently Asked Questions
Is there a faster way to calculate Two's Complement on the bench than using the 2^N formula?
Yes. The 'Invert and Add 1' method is much faster for mental math or quick whiteboard scribbles. Take the positive binary of 42 (00101010), flip every bit (logical NOT) to get 11010101, and add 1 to the least significant bit. The result is 11010110. This matches the formula perfectly and mirrors exactly what the ALU does in silicon.
Why does the Arduino int type use 16 bits while the ESP32 uses 32 bits?
The Arduino language reference for int defines the type based on the underlying AVR architecture's native register size, which is 16 bits. The ESP32 utilizes a 32-bit Xtensa architecture, meaning its native int is 32 bits. For cross-platform firmware, always use explicit <stdint.h> types like int16_t or int32_t to guarantee your binary conversions remain consistent regardless of the board you flash.
