What Is a Hexadecimal Number? Microcontroller Wiring & Code Guide

Hexadecimal is a base-16 numbering system using digits 0-9 and letters A-F to represent binary data in a compact, human-readable format. When you are wiring up an ESP32, debugging an Arduino sketch, or reading a datasheet for a new sensor, you will constantly run into values prefixed with 0x. Understanding this system is not just a software exercise; it is a fundamental requirement for configuring hardware registers, addressing I2C buses, and sending the correct byte payloads across your circuits.

The Core Translation: Hex, Decimal, and Binary in Practice

Microcontrollers process everything in binary (base-2), but reading a 16-bit binary string like 0011110001110110 is prone to human error. Hexadecimal (base-16) solves this by grouping binary bits into nibbles (4 bits), where each hex character represents exactly four binary digits. This makes it the perfect bridge between human-readable code and machine-level hardware states.

Below is a reference table of common hexadecimal values you will encounter when wiring sensors and configuring microcontroller peripherals.

Worked Example: Configuring an I2C Address and Payload

Let us look at a real-world scenario: initializing an SSD1306 OLED display over I2C using an Arduino or ESP32. The datasheet specifies the slave address as 0x3C (or 0x3D depending on the hardware strapping pin). But what does 0x3C actually mean, and how do we use it?

Step 1: Convert Hex to Decimal
The prefix 0x tells the compiler 'this is hex'. The value 3C has two digits. In base-16, the rightmost digit is the 1s place (16^0), and the next digit is the 16s place (16^1). The letter 'C' represents the decimal number 12.

• 3 × 16^1 = 3 × 16 = 48
• C (12) × 16^0 = 12 × 1 = 12
• 48 + 12 = 60

Step 2: Apply it in Code
When you use the Arduino Wire library, the Wire.beginTransmission() function accepts either decimal or hex. Because the datasheet uses hex, we stick to hex to prevent translation errors.

Wire.beginTransmission(0x3C); // Correct: Sends address 60
Wire.write(0xAE);             // Command to turn the display OFF
Wire.endTransmission();

If you accidentally dropped the 0x and wrote Wire.beginTransmission(3C), the code would fail to compile because 'C' is not a valid decimal digit. If you wrote Wire.beginTransmission(3), you would be addressing a completely different device on the bus, and your OLED would remain blank.

Where You Meet Hexadecimal in Real Circuits and Code

Hexadecimal is the lingua franca of digital electronics. You will rarely use it for analog calculations (like sizing a current-limiting resistor using Ohm's Law), but it is unavoidable in digital logic and communication protocols.

1. I2C and SPI Device Addressing

Every device on an I2C bus needs a unique 7-bit or 10-bit address. Manufacturers publish these in hex. When wiring multiple sensors (like a BME280 and an MPU6050), you must check their hex addresses to ensure they do not collide. If they share the same hex address, you must use a logic-level I2C multiplexer like the TCA9548A.

2. Direct Register Manipulation

When you need to toggle a pin faster than the standard digitalWrite() function allows, you write directly to the microcontroller's memory-mapped I/O registers. For example, on an ESP32, setting GPIO pin 2 high via the 1TC (one-shot set) register requires a bitmask. Pin 2 corresponds to bit 2, which is 0x04 in hex. Writing GPIO.out_w1ts = 0x04; executes in a single clock cycle.

3. RGB LED Color Codes

Addressable LEDs like the WS2812B (NeoPixel) expect a 24-bit data stream representing Red, Green, and Blue intensity. Instead of passing three separate decimal variables, libraries like FastLED accept a single 32-bit hex value. 0xFF0000 is pure red (255, 0, 0), 0x00FF00 is pure green, and 0x0000FF is pure blue. This maps perfectly to standard web color codes.

4. MAC Addresses and BLE UUIDs

Network interfaces and Bluetooth Low Energy (BLE) modules identify themselves using hex strings. An ESP32's MAC address looks like A4:CF:12:6B:89:00. When filtering BLE beacons in a smart home setup, you will match against these hex pairs, not decimal equivalents.

Common Confusions and How to Avoid Bricking Your Board

Misinterpreting a hex value is one of the most common ways hobbyists introduce subtle, hard-to-find bugs into their firmware. Watch out for these specific traps.

Hex Bytes vs. ASCII Characters

When sending data over UART or SPI to a display or a PC terminal, you must distinguish between the value of a byte and the character it represents.

If you want to send the letter 'A' to a serial terminal, you send the ASCII character 'A'. In hex, the ASCII value for 'A' is 0x41 (decimal 65).

If you write Serial.write(0x41);, the terminal prints A.
If you write Serial.print(0x41);, the Arduino converts the hex value to its decimal string equivalent and prints 65.
If you write Serial.write(41); (forgetting the 0x), you are sending decimal 41, which is the ASCII character ).

Leading Zeros Matter in Datasheets

A datasheet might specify a command byte as 0x0A. While mathematically identical to 0xA, the leading zero is a convention used by engineers to indicate that the value is a full 8-bit byte (two hex nibbles). When writing SPI arrays, always pad your hex values to two digits (e.g., 0x05 instead of 0x5) to maintain visual alignment and prevent bitwise shifting errors during code reviews.