How to Read and Send a Hexadecimal String in Embedded Systems

A hexadecimal string is a sequence of base-16 characters (0-9 and A-F) used to represent binary data in a compact, human-readable format for microcontrollers and digital systems. While a hex string doesn't alter the physical copper traces or voltage levels on your breadboard, it fundamentally changes how you format data payloads, address memory registers, and debug communication protocols between digital ICs. Beginners commonly confuse a hex string with an ASCII text string, or mistakenly assume that the 0x compiler prefix is part of the actual data payload transmitted over the wire.

The Anatomy of a Hexadecimal String

Digital logic operates in binary (base-2), but reading a 32-bit register as 11010010111100001010101011001110 is a fast track to debugging fatigue. Hexadecimal (base-16) solves this by mapping exactly four binary bits (a nibble) to a single character. Two hex characters perfectly represent one 8-bit byte, which is the fundamental unit of data in almost all modern microcontrollers.

When you write code in C++ for an Arduino or ESP32, the compiler needs to know whether 10 means ten in decimal, or ten in hex (which is 16 in decimal). This is why we use the 0x prefix in source code. However, this prefix is strictly for the compiler. It is never transmitted over a physical wire.

Worked Numeric Example: DFPlayer Mini UART Payload

Let's look at a real-world scenario where you must construct and send a hexadecimal string to a peripheral. The DFPlayer Mini is a popular, low-cost MP3 module that communicates via UART at 9600 baud. To tell the module to play track #1, you cannot simply send the ASCII character '1'. You must send a specific 8-byte hex command sequence.

The required hexadecimal string for this command is: 7E FF 06 0F 00 00 01 EF

Here is the byte-by-byte breakdown of what that string actually means to the hardware:

• Byte 1 (7E): Start byte. Tells the DFPlayer a new command packet is beginning.
• Byte 2 (FF): Version number of the protocol.
• Byte 3 (06): Number of bytes remaining in the payload (excluding start, version, length, and end bytes).
• Byte 4 (0F): The actual command. 0F in hex is 15 in decimal, which maps to the "Play" command in the DFPlayer datasheet.
• Byte 5 (00): Feedback flag. 00 means no feedback required from the module.
• Byte 6 & 7 (00 01): The parameter. This is a 16-bit integer representing the track number. 00 is the high byte, 01 is the low byte (Track 1).
• Byte 8 (EF): End byte. Terminates the packet.

In your ESP32 or Arduino sketch, you define this hexadecimal string as a byte array and push it to the hardware serial buffer:

// Define the hexadecimal string as a byte array
byte playTrack1[] = {0x7E, 0xFF, 0x06, 0x0F, 0x00, 0x00, 0x01, 0xEF};

// Transmit the exact binary values over UART2
Serial2.write(playTrack1, sizeof(playTrack1));

If you attempt to send the literal text string "7EFF060F000001EF" using Serial.print(), the DFPlayer will receive 16 ASCII characters (which is 16 bytes of text data) and will completely ignore the command, as it is expecting 8 raw binary bytes.

Where You Meet Hexadecimal Strings in Practice

Once you understand the byte-level translation, you will start seeing hex strings everywhere in embedded electronics and home automation.

1. MAC Addresses and Wi-Fi Provisioning

Every network interface has a unique 48-bit MAC address, universally represented as a 12-character hex string (e.g., A4:CF:12:6B:33:8F). When configuring ESP-NOW peer-to-peer communication on an ESP32, the Espressif API requires you to pass the target peer's MAC address as a 6-byte hex array. Misaligning these hex pairs is the number one cause of ESP-NOW pairing failures.

2. Addressable RGB LEDs (WS2812B)

When programming NeoPixels, color values are passed as 24-bit hex strings. A pure red color is FF0000. However, because the WS2812B chipset internally wires its dies in Green-Red-Blue order, you must pass the hex string 00FF00 to the FastLED library to achieve physical red light. This hardware quirk is entirely managed via hex string manipulation in the library's C++ backend.

3. Intel HEX Firmware Files

When you compile code in the Arduino IDE or PlatformIO, the resulting binary is often converted into an Intel HEX file before being flashed via a bootloader. This is an ASCII text file where every line is a structured hexadecimal string containing memory addresses, byte counts, and checksums. Bootloaders parse these hex strings line-by-line to write your program into the microcontroller's flash memory.

The Endianness Trap: Big vs. Little

The most common point of failure when working with multi-byte hexadecimal strings is endianness—the order in which bytes are stored or transmitted.

Suppose you need to send a 16-bit sensor reading of 0x1234 over an I2C bus.

• Big-Endian: The most significant byte is sent first. The hex string on the wire is 12 34. Network protocols (like TCP/IP) and the DFPlayer example above use Big-Endian.
• Little-Endian: The least significant byte is sent first. The hex string on the wire is 34 12. Most ARM Cortex-M microcontrollers (including the ESP32 and STM32) store multi-byte variables in memory using Little-Endian.

Frequently Asked Questions

char hexText[] = "1A4F";
long decimalValue = strtol(hexText, NULL, 16);
// decimalValue is now 6735