How to Read and Use a List of Numbers in Binary for Microcontroller Registers

The Direct Answer: What Is a List of Numbers in Binary?

A list of numbers in binary is a sequence of base-2 values (using only 0s and 1s) that directly maps to the physical high (typically 3.3V or 5V) and low (0V) voltage states of digital logic circuits and microcontroller registers.

What it changes in a real circuit: Writing a binary list to a hardware port register changes the physical voltage on multiple GPIO pins simultaneously. Instead of toggling pins one by one in software, you push an entire list of states to the port in a single clock cycle, controlling relays, LED matrices, or motor drivers with precise nanosecond-level timing.

What people commonly confuse it with: Makers often confuse a binary string (a single mathematical number represented in base-2, like 1010) with a list of binary numbers (an array of discrete boolean states or bytes, like [1, 0, 1, 0] or [0b1010, 0b1100]). In embedded C/C++, we usually pack these discrete lists into single byte or hex variables to write to hardware registers efficiently, bridging the gap between software arrays and physical hardware pins.

Worked Numeric Example: Configuring an 8-Bit Shift Register

Let us look at a real bench scenario: driving eight 5V relays using a Texas Instruments 74HC595 8-bit shift register. The shift register takes a serial list of bits and outputs them in parallel across pins Q0 through Q7.

The Goal: We need to turn ON relays 1, 3, 5, and 8 (connected to Q0, Q2, Q4, and Q7) while keeping the others OFF.

1. Map the physical pins to a binary list: We assign '1' for HIGH (relay ON) and '0' for LOW (relay OFF). Remember that Q0 is the Least Significant Bit (Bit 0) and Q7 is the Most Significant Bit (Bit 7).
2. Write the list from MSB to LSB:
   • Bit 7 (Q7): 1 (ON)
   • Bit 6 (Q6): 0 (OFF)
   • Bit 5 (Q5): 0 (OFF)
   • Bit 4 (Q4): 1 (ON)
   • Bit 3 (Q3): 0 (OFF)
   • Bit 2 (Q2): 1 (ON)
   • Bit 1 (Q1): 0 (OFF)
   • Bit 0 (Q0): 1 (ON)
3. Combine into a binary number: 10010101
4. Convert to Hexadecimal for code: Grouping into nibbles (1001 and 0101) gives us 0x95. In decimal, this is 149.

Here is how you push that list to the hardware using an Arduino:

// Pin definitions
const int dataPin = 11;  // SER (Serial Data Input)
const int latchPin = 10; // SRCLK (Shift Register Clock)
const int clockPin = 9;  // RCLK (Storage Register Clock)

void setup() {
  pinMode(dataPin, OUTPUT);
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
}

void loop() {
  // The binary list 10010101 packed into a single byte
  byte relayStates = 0x95; 

  digitalWrite(latchPin, LOW);
  // MSBFIRST matches our Q7-to-Q0 mapping
  shiftOut(dataPin, clockPin, MSBFIRST, relayStates);
  digitalWrite(latchPin, HIGH);
  
  delay(1000);
}

Where You Meet This in Practice: Hardware and Embedded Systems

You will rarely type out long arrays of 1s and 0s in production firmware, but the concept of binary lists governs how microcontrollers interact with the physical world.

• Direct Port Manipulation: On an Arduino Uno (ATmega328P), writing PORTD = B11001100; instantly sets pins D4-D7 HIGH and D0-D3 LOW. This bypasses the overhead of digitalWrite() and executes in a single clock cycle.
• Logic Analyzer Traces: When debugging SPI or I2C buses with a Saleae or DSLogic analyzer, the software decodes voltage transitions into a list of binary numbers. Reading this list tells you exactly which register addresses a sensor is requesting.
• Memory Mapping and EEPROM: When dumping or flashing memory, data is handled in lists of binary bytes. A 4KB EEPROM holds a list of 4,096 discrete 8-bit binary numbers.

A 32-bit ARM register (like those on the ESP32 or STM32) holds a list of 32 binary states, allowing you to toggle 32 physical pins in exactly 1 clock cycle—typically under 6 nanoseconds on a 160MHz core.

Reference Chart: Decimal, Hex, and Binary Lists (0-15)

When working with 4-bit nibbles (common in I2C addressing and LCD displays), memorizing this base list saves you from opening a calculator. This table assumes an Active-High logic configuration.

Frequently Asked Questions About Binary Number Lists

byte myValue = 149; // Decimal for 10010101
int binaryList[8];

for (int i = 0; i < 8; i++) {
  binaryList[i] = bitRead(myValue, i);
}