The Complete Hexadecimal and Binary Table for Embedded Firmware

A hexadecimal and binary table maps base-16 (hex) and base-2 (binary) values to base-10 (decimal) for digital logic, memory addressing, and embedded firmware. If you are configuring an ESP32 GPIO register, decoding an I2C sensor payload, or setting a PWM duty cycle, you need to know exactly what 0x55 or 0b01010101 means in physical voltage states. Use binary for individual pin mapping and bitwise toggles, and use hexadecimal for byte-level register masks, memory pointers, and communication addresses.

The Complete Hexadecimal and Binary Reference Table

This table provides the fundamental 4-bit nibble mappings (0x0 to 0xF) alongside the most queried 8-bit byte boundaries and standard test patterns. Bookmark this page and use the quick-jump IDs (like #row-0x55) to navigate directly to your target value.

How to read this table: The Decimal column is your human-readable baseline. The Hex column (prefixed with 0x) is used for memory addresses and I2C/SPI commands. The Binary column (prefixed with 0b) shows the exact physical state of 4 or 8 hardware pins (1 = HIGH/3.3V, 0 = LOW/GND). The Common Embedded Use column tells you where this specific value appears in real-world microcontroller datasheets.

Which Column Applies to Your Hardware Installation

Just as an electrical panel schedule dictates which wire color goes to which breaker, your specific hardware task dictates which column of the hexadecimal and binary table you must use. Using the wrong base leads to unreadable code and silent register misconfigurations.

• The Binary Column (0b): Use this when your 'installation' involves direct GPIO pin mapping or single-bit toggles. If you are setting up an ESP32 pin matrix where Bit 0 is SDA and Bit 1 is SCL, writing 0b00000011 makes the physical pin states instantly visible to the human eye. Espressif's GPIO documentation heavily relies on binary masks for pin routing.
• The Hexadecimal Column (0x): Use this for I2C addresses, SPI command bytes, memory pointers, and multi-byte register configurations. If you are configuring a sensor with an I2C address of 104 (decimal), writing 0x68 is the industry standard. It groups perfectly into 4-bit nibbles, making it easier to spot errors than a long string of 1s and 0s.
• The Decimal Column: Reserve this for human-scale physical quantities: PWM duty cycles (e.g., 50% brightness), ADC voltage thresholds (e.g., 2048 for mid-scale on a 12-bit ADC), and baud rates (e.g., 115200).

How Bit-Shifting and Masking Modify Base Values

In wire sizing, ampacity derating rows modify the base current capacity based on ambient temperature and conduit fill. In digital logic, bit-shifting and masking modify the base binary value based on register position and bus width. A static 0x01 in the table means 'Bit 0 HIGH', but in your firmware, that value is rarely used without modification.

Here is how shifting alters the base table values:

• Left Shift (<<): If you need to set Bit 4 HIGH, you don't look up '16' in the table. You take the base value 0x01 (or 0b00000001) and shift it: 1 << 4. The binary becomes 00010000 (Hex 0x10, Decimal 16). This is how microcontroller HAL (Hardware Abstraction Layer) libraries define pin masks dynamically.
• Bitwise AND Masking (&): To extract the lower nibble of an incoming I2C byte, you apply a mask from the table. If the incoming byte is 0xB7 (10110111), applying the 0x0F mask (00001111) via 0xB7 & 0x0F zeroes out the top four bits, leaving exactly 0x07.
• Bitwise OR Setting (|): To force Bit 7 HIGH without disturbing the other 7 bits in a control register, you OR the current register value with the 0x80 mask from the table.

Decision Tree: Selecting the Right Numeral Base

Do not mix numeral bases arbitrarily. Use this decision path to determine the exact format for your next line of embedded C/C++ or MicroPython code.

Default Pick: If you are ever in doubt while writing low-level register configuration code, default to Hexadecimal (0x). It is the universal language of microcontroller datasheets (from TI, STMicroelectronics, and Espressif) and maps cleanly to both 8-bit bytes and 32-bit words without the visual clutter of 32-character binary strings.

What This Table Cannot Tell You (Edge Cases and Limits)

A static conversion table assumes unsigned, big-endian, positive integers. Real-world firmware debugging requires understanding what the table hides. According to standard digital logic principles outlined in resources like All About Circuits' Digital Textbook, you must account for the following edge cases:

1. Signed Integers and Two's Complement

The table shows 0xFF as 255. This is true for an unsigned char (8-bit unsigned integer). However, if your variable is declared as a signed 8-bit integer (int8_t), 0xFF represents -1. The MSB (Bit 7, or 0x80) acts as the sign bit. If you are reading temperature data from an I2C sensor like the BMP280, a raw hex value of 0xF0 is not +240; it is -16. Always check the sensor datasheet to confirm if the payload is signed or unsigned before casting the hex value.

2. Endianness (Byte Order in Memory)

The table maps a single byte. But when you write a 16-bit or 32-bit hex value to memory, the order of the bytes depends on the microcontroller's architecture. The ESP32 (Xtensa LX6) and most ARM Cortex-M chips (STM32, RP2040) are Little-Endian. This means the least significant byte is stored at the lowest memory address. If you write the 32-bit hex value 0x12345678 to a memory buffer, it is physically stored in RAM as 0x78, 0x56, 0x34, 0x12. If you transmit this buffer over UART without accounting for endianness, the receiving device will read it backward.

3. Floating-Point Representation (IEEE 754)

You cannot use this table to map floating-point numbers (e.g., 3.14) to hex. Floating-point values follow the IEEE 754 standard, which splits the 32 bits into a sign bit, an 8-bit exponent, and a 23-bit mantissa. The hex representation of 3.14f is 0x4048F5C3, which looks nothing like the integer '3'. If you need to send a float over an I2C bus, cast it to a byte array using a union or memcpy in C, rather than attempting manual hex conversion.