When you are writing bare-metal C for an ESP32, configuring port registers on an ATmega328P, or debugging a shift register chain on your workbench, you are not thinking in base-10. You are thinking in bits. A binary to denary table (base-2 to base-10) is the fundamental lookup tool for translating hardware-level logic states into human-readable values. Whether you are mapping a 8-bit DIP switch array to a microcontroller input or calculating the maximum payload of a 16-bit timer, having the exact threshold values memorized or bookmarked saves hours of debugging.
This reference provides the critical architectural boundaries for 4-bit, 8-bit, and 16-bit systems, grounded in standard positional numeral systems (ISO/IEC 80000-2) and standard digital logic practices. We will cover how to read the table, how signed integer limits 'derate' your maximum positive values, and what this table cannot tell you about memory architecture.
How to Read This Binary to Denary Reference Table
Before jumping to the numbers, you need to understand the columns and how they apply to your specific hardware installation. This table is structured around standard base-2 positional notation, cross-referenced with hexadecimal and two's complement signed limits.
- Binary (Base-2): The raw logic states (0V/GND or 3.3V/5V). Read from right to left (Least Significant Bit to Most Significant Bit).
- Denary (Base-10 Unsigned): The standard positive integer value. This is what your serial monitor prints when you use an unsigned integer type.
- Signed 8-Bit (Two's Complement): The 'derated' value. If your microcontroller register is configured as a signed integer (e.g.,
int8_tin C), values above 127 wrap into negative numbers. - Hex (Base-16): The standard shorthand for memory addresses and register masks (e.g.,
0xFF).
The Master Binary to Denary Table (Quick-Jump Boundaries)
While a literal table of all 65,536 16-bit combinations is impractical for a single page, engineers and makers rarely need to look up arbitrary mid-range numbers. You need the bit-flip boundaries, power-of-2 thresholds, and register limits. The table below provides the complete 4-bit sequence, all critical 8-bit boundaries, and the 16-bit architectural limits. Use the bookmark-friendly IDs to jump to your required register size.
| Binary (Base-2) | Denary (Unsigned) | Signed 8-Bit | Hex | Hardware Context / Register Note |
|---|---|---|---|---|
| Complete 4-Bit Sequence (Nibble) | ||||
| 0000 | 0 | 0 | 0x0 | Logic LOW / Cleared Register |
| 0001 | 1 | 1 | 0x1 | Bit 0 set |
| 0010 | 2 | 2 | 0x2 | Bit 1 set |
| 0011 | 3 | 3 | 0x3 | Bits 0-1 set |
| 0100 | 4 | 4 | 0x4 | Bit 2 set |
| 0101 | 5 | 5 | 0x5 | Bits 0,2 set |
| 0110 | 6 | 6 | 0x6 | Bits 1,2 set |
| 0111 | 7 | 7 | 0x7 | Max positive 3-bit |
| 1000 | 8 | -8 | 0x8 | Bit 3 set (Signed wraps negative) |
| 1001 | 9 | -7 | 0x9 | Bits 0,3 set |
| 1010 | 10 | -6 | 0xA | Bits 1,3 set |
| 1011 | 11 | -5 | 0xB | Bits 0,1,3 set |
| 1100 | 12 | -4 | 0xC | Bits 2,3 set |
| 1101 | 13 | -3 | 0xD | Bits 0,2,3 set |
| 1110 | 14 | -2 | 0xE | Bits 1,2,3 set |
| 1111 | 15 | -1 | 0xF | Max 4-bit unsigned / -1 signed |
| Critical 8-Bit Boundaries (1 Byte) | ||||
| 0001 0000 | 16 | 16 | 0x10 | Bit 4 set |
| 0010 0000 | 32 | 32 | 0x20 | Bit 5 set |
| 0100 0000 | 64 | 64 | 0x40 | Bit 6 set |
| 0111 1111 | 127 | 127 | 0x7F | MAX 8-bit Signed Positive |
| 1000 0000 | 128 | -128 | 0x80 | Bit 7 set (Signed overflow to MIN) |
| 1100 0000 | 192 | -64 | 0xC0 | Bits 6,7 set |
| 1111 1111 | 255 | -1 | 0xFF | MAX 8-bit Unsigned / All pins HIGH |
| Critical 16-Bit Boundaries (2 Bytes / Standard Timer Limits) | ||||
| 0000 0001 0000 0000 | 256 | 256 | 0x0100 | 9th bit set (Overflows 8-bit register) |
| 0000 0100 0000 0000 | 1,024 | 1,024 | 0x0400 | 1 KB memory boundary |
| 0111 1111 1111 1111 | 32,767 | 32,767 | 0x7FFF | MAX 16-bit Signed Positive |
| 1000 0000 0000 0000 | 32,768 | -32,768 | 0x8000 | 15th bit set (Signed overflow) |
| 1111 1111 1111 1111 | 65,535 | -1 | 0xFFFF | MAX 16-bit Unsigned (Timer rollover) |
Source: Standard positional numeral system base-2 conversion per ISO/IEC 80000-2, with two's complement signed integer limits standard in C/C++ (ISO/IEC 9899).
Register Limits, Bit-Shifting, and Derating Your Values
In wire sizing, 'derating' reduces ampacity due to thermal constraints. In digital logic and microcontroller programming, derating refers to the reduction of your maximum positive value when switching from unsigned to signed data types, or the loss of data when bit-shifting beyond your hardware's register width.
Which Column Applies to Your Installation?
Your 'installation' in this context is your target microcontroller's architecture. If you are programming an older Arduino Uno (ATmega328P), your default port registers (like PORTB or PINB) are strictly 8-bit. Writing a denary value of 256 to an 8-bit register will result in a silent overflow, wrapping back to 0. If you are using an ESP32-WROOM-32, the GPIO registers (like GPIO_OUT_REG) are 32-bit, but the physical pins are still mapped to specific bit positions. Always match your denary value to the physical bit-width of the hardware register you are manipulating.
How Signed Limits 'Derate' the Base Value
Look at the 1000 0000 row in the table. As an unsigned 8-bit integer, it is a healthy 128. But if your compiler treats that byte as a signed int8_t, the Most Significant Bit (MSB) becomes the sign bit. The value instantly 'derates' to -128. This two's complement wrap-around is the number one cause of erratic motor controller behavior and sensor misreads when hobbyists accidentally cast unsigned ADC readings into signed variables.
What This Table Cannot Tell You
A binary to denary table is a mathematical absolute, but it lacks hardware context. Here is what you must verify on the bench:
- Endianness: When combining two 8-bit bytes into a 16-bit denary value (e.g., reading an I2C temperature sensor like the BME280), the table won't tell you if the Most Significant Byte comes first (Big-Endian) or last (Little-Endian). You must check the sensor's datasheet.
- Floating Point (IEEE 754): This table only covers integers. If you are trying to decode a 32-bit float transmitted over UART, the binary sequence does not map linearly to denary. It requires IEEE 754 mantissa and exponent extraction.
- Binary Coded Decimal (BCD): Some legacy RTC (Real Time Clock) modules output time in BCD. In BCD, the binary
1001 0110does not equal denary150; it equals96(9 and 6 in denary). Always verify if your peripheral uses pure binary or BCD.
Binary to Denary Table FAQ
How do I convert a 16-bit binary to denary table value manually?
Write the bit positions above the binary string, starting from 0 on the far right up to 15 on the far left (1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768). Add together only the position values where the binary bit is a 1. For example, 0000 0000 0000 1010 has 1s in the 8 and 2 positions. 8 + 2 = denary 10.
Why does my binary to denary table show negative numbers for 8-bit values over 127?
This is due to Two's Complement, the standard method computers use to represent signed integers. In an 8-bit system, the 8th bit (the 128 column) is hijacked to act as a negative sign indicator. Therefore, the maximum positive denary value is 127 (0111 1111). Any binary value with the MSB set to 1 is interpreted as a negative number, ranging from -1 to -128.
What is the difference between a denary and decimal conversion?
There is no mathematical difference. 'Denary' is simply the preferred term in British, Commonwealth, and some international educational systems to describe the base-10 numeral system, distinguishing it clearly from 'decimal fractions'. In US-centric programming and engineering, 'decimal' is used interchangeably to mean base-10 integers. Both refer to the exact same numbers in this table.
How do bitwise shifts affect my binary to denary conversion?
A left bitwise shift (<< 1) multiplies the denary value by 2, provided it does not overflow the register width. A right shift (>> 1) divides the denary value by 2, discarding the remainder (the least significant bit). If you shift an 8-bit denary value of 128 (1000 0000) left by one position, the 1 falls off the edge of the 8-bit register, and the result wraps to denary 0, not 256.
