How to Read Hexadecimal Code in Embedded Systems: ESP32 I2C Memory Dump Guide

Hexadecimal (base-16) is the native language of embedded hardware. While humans count in base-10 (decimal) and microcontrollers process in base-2 (binary), hexadecimal bridges the gap. One hex digit represents exactly one nibble (4 bits), and two hex digits represent one full byte (8 bits). When you look at an I2C sensor register map, a MAC address, or a serial memory dump, you are reading hex code. If your serial monitor outputs 0x4A, that is decimal 74, or binary 01001010. Understanding how to read, parse, and debug hexadecimal code is the difference between blindly copying library code and actually engineering a reliable embedded system.

The Hexadecimal Decision Path: Base-16 vs Base-10 vs Base-2

Choosing the right numerical format depends entirely on what hardware layer you are interacting with. Use this decision tree to determine how to format your serial outputs and variable declarations in C++.

The Default Pick: If you are communicating with an external IC over a serial bus (I2C, SPI, UART, CAN), always use Hexadecimal. Datasheets specify registers in hex, and debugging bus collisions requires matching your logic analyzer output to your code.

Project Build: Dumping Hex Memory from an AT24C32 EEPROM

To practice reading and parsing hex code, we will build a memory dumper. We will interface an ESP32 with an AT24C32 I2C EEPROM, read raw bytes from its memory addresses, and format them into a standard hex dump on the serial monitor.

Parts List

• MCU: ESP32-WROOM-32 DevKit V1 (30-pin variant)
• Memory: AT24C32 I2C EEPROM module (32,768 bits / 4KB)
• Passives: 2x 4.7kΩ pull-up resistors (if not pre-soldered on the module)
• Wiring: 22 AWG solid core jumper wires

Pin Mapping Table

Compilable ESP32 Code: Reading and Formatting Hex Bytes

This code targets the ESP32-WROOM-32 DevKit V1 (30-pin) using the Arduino framework. It includes explicit pin definitions, I2C error handling, and formatted hex output using Serial.printf.

#include <Wire.h>

// Pin Definitions for ESP32-WROOM-32 DevKit V1
#define PIN_SDA 21
#define PIN_SCL 22
#define I2C_FREQ 400000 // 400kHz Fast Mode

// AT24C32 Base Address (A0, A1, A2 tied to GND)
#define EEPROM_ADDR 0x50 

void setup() {
  Serial.begin(115200);
  delay(1000); // Allow serial monitor to connect
  
  // Initialize I2C with explicit pins and frequency
  Wire.begin(PIN_SDA, PIN_SCL, I2C_FREQ);
  Serial.println('ESP32 Hex Memory Dumper Initialized.');
  
  // Write a test byte to verify communication
  writeEEPROM(0x0000, 0xA5);
  
  // Dump the first 64 bytes in hexadecimal format
  dumpHexMemory(0x0000, 64);
}

void loop() {
  // Idle
}

void writeEEPROM(unsigned int eeaddress, byte data) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write((int)(eeaddress >> 8));   // MSB of memory address
  Wire.write((int)(eeaddress & 0xFF)); // LSB of memory address
  Wire.write(data);
  uint8_t error = Wire.endTransmission();
  
  if (error != 0) {
    Serial.printf('Write Failed. I2C Error Code: %d\n', error);
  } else {
    Serial.printf('Wrote 0x%02X to address 0x%04X\n', data, eeaddress);
  }
  delay(10); // AT24C32 requires ~5ms write cycle time
}

byte readEEPROM(unsigned int eeaddress) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write((int)(eeaddress >> 8));   // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  uint8_t error = Wire.endTransmission();
  
  if (error != 0) {
    Serial.printf('Read Address Failed. I2C Error Code: %d\n', error);
    return 0xFF; // Return 0xFF as an error flag
  }
  
  Wire.requestFrom(EEPROM_ADDR, 1);
  if (Wire.available()) {
    return Wire.read();
  }
  return 0xFF;
}

void dumpHexMemory(unsigned int startAddr, int length) {
  Serial.println('\n--- HEX DUMP START ---');
  for (int i = 0; i < length; i++) {
    if (i % 16 == 0) {
      Serial.printf('\n0x%04X: ', startAddr + i); // Print row address
    }
    byte val = readEEPROM(startAddr + i);
    Serial.printf('%02X ', val); // Print padded hex byte
  }
  Serial.println('\n--- HEX DUMP END ---');
}

Debugging Hex I/O: Fixing NACK and 0xFF Dump Errors

When reading hex dumps from I2C devices, hardware faults manifest as specific hex patterns or Wire library error codes. Here is how to decode them.

Symptom 1: Serial monitor prints 'Error Code: 2'

Exact Error String: Read Address Failed. I2C Error Code: 2

Meaning: According to the Arduino Wire library documentation, a return value of 2 from Wire.endTransmission() means 'NACK on transmit of address'. The ESP32 sent the address 0x50, but no device acknowledged it.

First Three Things to Check:

1. Pull-up Resistors: Verify 4.7kΩ resistors are physically pulling SDA and SCL to 3.3V. Without them, the lines float, and the ESP32 cannot generate a valid START condition.
2. Address Pin Strapping: Use a multimeter to check the A0, A1, and A2 pins on the EEPROM. If A0 is accidentally bridged to VCC, the address is 0x51, not 0x50.
3. Logic Level Mismatch: The ESP32 operates at 3.3V. If your EEPROM module has an onboard 5V LDO but lacks a bidirectional logic level shifter, the 3.3V HIGH from the ESP32 might not cross the 5V IC's $V_{IH}$ (Input High Voltage) threshold.

Symptom 2: Hex Dump is entirely 'FF FF FF FF'

Exact Error String: Output shows FF for every byte, but no I2C Error Codes are thrown.

Meaning: The I2C bus is physically working (address ACKed), but the memory array is returning the unprogrammed/erased state. In Flash and EEPROM technology, an erased bit defaults to 1. Therefore, an erased byte is 11111111 in binary, which is 0xFF in hex.

Ranked Causes:

1. Unwritten Memory: You are reading an address range you haven't written to yet. This is normal behavior for a fresh AT24C32.
2. Write Cycle Timeout: The AT24C32 requires up to 5ms to complete an internal write cycle. If your code attempts to read or write again before this completes, the IC ignores the bus. Ensure delay(10); follows every write operation.
3. Address Overflow: The AT24C32 has 4,096 bytes (addresses 0x0000 to 0x0FFF). If you attempt to read 0x1000, the internal pointer rolls over or returns 0xFF depending on the specific silicon revision.

Hexadecimal Conversion and Embedded Register Reference Chart

When parsing hex dumps, you must mentally map base-16 to base-10 and base-2. Furthermore, certain hex values carry special significance in embedded protocols.

Endianness Warning: When reading 16-bit registers over I2C, you will receive two hex bytes. According to Microchip AT24C32 datasheets and standard I2C conventions, data is transmitted Big-Endian (Most Significant Byte first). If your sensor outputs 0x1A then 0x05, the 16-bit hex value is 0x1A05 (decimal 6661), not 0x051A. The ESP32's internal ARM memory is Little-Endian, which frequently causes byte-swap bugs when casting raw I2C buffers directly to uint16_t pointers.

Extending and Simplifying the Hex Reader

Once you have verified basic hex reading, you can scale this architecture for production firmware.

• Extend to Page Reads: The AT24C32 supports 32-byte page reads. Instead of calling Wire.requestFrom(ADDR, 1) in a loop, request 32 bytes at once and parse the buffer. This reduces I2C bus overhead by over 80% and prevents clock-stretching timeouts.
• Add ASCII Translation: To make hex dumps readable, modify the dumpHexMemory function to print a secondary column. If the hex byte falls between 0x20 (Space) and 0x7E (Tilde), print the ASCII character; otherwise, print a dot (.). This mimics standard Linux hexdump -C output.
• Simplify with Structs: Instead of manually shifting hex bytes (val << 8), define a C++ struct that matches the sensor's register map and use memcpy to map the raw hex buffer directly into typed variables. This eliminates bitwise math errors and makes the code self-documenting.

Mastering hexadecimal code is not about memorizing conversion tables; it is about recognizing the physical hardware states those numbers represent. When you see 0xFF, you should immediately picture an un-driven pull-up line or an erased flash cell. When you see 0x55, you should think of a UART baud-rate synchronization preamble. By building physical I/O projects and forcing yourself to debug raw bus dumps, base-16 becomes a natural extension of your hardware intuition.