Hexadecimal Notation in Electronics: Registers, I2C, and Firmware

Hexadecimal notation is a base-16 numbering system using digits 0-9 and letters A-F to represent binary data in a compact, human-readable format. To be clear on what it changes in a real installation: hex does not alter the physical behavior of a circuit or the voltage levels on a wire, but it drastically changes how we configure microcontroller registers, address sensors on a bus, and define memory maps in firmware. The most common confusion among beginners is treating the 0x prefix as a mathematical operator rather than a syntactic marker, or mixing up hex (base-16) with octal (base-8) when reading legacy datasheets or C-code.

The Core Translation Table: Hex, Decimal, and Binary

Before writing firmware, you must internalize the relationship between hex, decimal, and binary. The table below avoids generic counting and instead focuses on the specific hex values you will encounter repeatedly when configuring hardware registers, setting I2C addresses, or testing logic lines.

Notice how 0x55 and 0xAA are exact bitwise inverses of each other. When debugging a custom PCB with an 8-bit shift register like the 74HC595, sending these two hex values back-to-back will toggle every output pin high and low, allowing you to verify solder joints with a multimeter or logic probe without writing complex loop logic.

Worked Example: Configuring an MCP23017 GPIO Expander

To see how hexadecimal notation translates directly to physical pin states, let us configure an I2C GPIO expander. The Microchip MCP23017 provides 16 extra I/O pins. Suppose we are building a control panel and need Port A (pins GPA0 through GPA7) configured so that pins 0-3 are inputs with internal pull-up resistors (for reading pushbuttons), and pins 4-7 are outputs (for driving indicator LEDs).

We must write to two specific internal registers on the chip:

1. IODIRA (Address 0x00): The Input/Output Direction register. A 1 bit means input, a 0 bit means output.
2. GPPUA (Address 0x0C): The Pull-Up resistor register. A 1 bit enables the 100kΩ internal pull-up.

The Math:
We want pins 0, 1, 2, and 3 to be inputs. In binary, that is 0000 1111 (reading from bit 7 down to bit 0).
Splitting into nibbles: 0000 is 0 in hex. 1111 is F in hex.
Therefore, the hex value to write is 0x0F.

Here is the exact Arduino/ESP32 C++ code using the standard Wire library to push these hex values to the hardware:

#include <Wire.h>

// Default I2C address for MCP23017 with all address pins grounded
#define MCP_ADDR 0x20 

void setup() {
  Wire.begin();
  
  // 1. Set Port A Direction (IODIRA register is at 0x00)
  Wire.beginTransmission(MCP_ADDR);
  Wire.write(0x00); // Target IODIRA register
  Wire.write(0x0F); // Binary 00001111: Pins 0-3 Inputs, 4-7 Outputs
  Wire.endTransmission();

  // 2. Enable Pull-ups on Port A (GPPUA register is at 0x0C)
  Wire.beginTransmission(MCP_ADDR);
  Wire.write(0x0C); // Target GPPUA register
  Wire.write(0x0F); // Enable pull-ups ONLY on the input pins (0-3)
  Wire.endTransmission();
}

void loop() {
  // Read inputs and toggle outputs...
}

If you mistakenly wrote 0xF0 instead of 0x0F, the binary becomes 1111 0000. Your pushbuttons on pins 0-3 would fail to register because they are now configured as outputs driving LOW, and your LEDs on pins 4-7 would float because they are configured as high-impedance inputs. This single nibble swap is one of the most common firmware bugs in I2C expansion.

Where You Meet Hexadecimal Notation in Practice

Beyond GPIO expanders, hex is the lingua franca of digital electronics. You will encounter it in these specific scenarios:

• I2C Bus Scanning: When you wire up a BME280 environmental sensor and run an I2C scanner script, the serial monitor will report 0x76 or 0x77. These are 7-bit addresses. If a library asks for an 8-bit address, you must shift the hex value left by one bit (e.g., 0x76 becomes 0xEC for write operations).
• Addressable LED Color Mixing: Standard web colors use an RGB hex format (e.g., pure green is 0x00FF00). However, the WS2812B (NeoPixel) data protocol uses a GRB byte order. To output pure green to a WS2812B strip via raw SPI or I2S DMA, you must send the hex sequence 0xFF0000 (Green=FF, Red=00, Blue=00). Failing to translate the hex color space to the hardware's physical byte order results in incorrect colors.
• MAC Addresses and WiFi Provisioning: Every ESP32-WROOM-32 module has a burned-in base MAC address represented as six hex pairs (e.g., AA:BB:CC:11:22:33). When implementing MAC address filtering on a router or generating unique MQTT client IDs based on hardware IDs, you will parse these hex strings into byte arrays.
• Memory-Mapped Registers: On bare-metal ARM or RISC-V microcontrollers, configuring a PWM timer involves writing directly to memory addresses. You might write 0x40010000 to a base pointer, then add an offset of 0x24 to reach the specific duty-cycle register. Hexadecimal makes calculating these memory boundaries trivial compared to decimal.

Common Pitfalls and FAQ

Mastering hexadecimal notation is not about memorizing every conversion; it is about recognizing the patterns (nibbles, masks, and standard addresses) that bridge the gap between human-readable code and the physical logic gates on your workbench.