The Ultimate Binary Cheat Sheet for Microcontrollers and Digital Logic

Binary is a base-2 numbering system using only 0s and 1s to represent electrical states (LOW/OFF and HIGH/ON) in digital circuits and microcontrollers. This binary cheat sheet gives you the exact translations, bitmasks, and logic operations needed to map physical pin voltages to logical data on the bench. What this changes in a real circuit or installation is your ability to read parallel sensors, configure hardware addresses, and manipulate microcontroller port registers directly—bypassing slow, abstracted library functions to achieve deterministic timing. Beginners commonly confuse pure binary with hexadecimal (which is merely a human-friendly shorthand for binary) or Binary-Coded Decimal (BCD), which restricts 4-bit nibbles to represent only the digits 0-9.

The 8-Bit Binary Cheat Sheet Reference Table

When you are writing embedded C or C++ for an Arduino Uno (ATmega328P) or an ESP32, you rarely need to count to 255 in binary. Instead, you need to recognize powers of two (single-bit masks) and nibble boundaries (hex conversions). Keep this table bookmarked for your next logic analyzer session.

Worked Example: Bitwise Port Manipulation on an ATmega328P

Let’s look at a real-world scenario where this binary cheat sheet saves you from writing eight separate digitalWrite() commands. Suppose you are using an Arduino Uno and need to update a parallel LCD bus connected to PORTD (digital pins 0 through 7).

The Scenario: You want to set Pin 5 and Pin 2 HIGH, and force Pin 3 LOW, without altering the current state of the other pins on that port.

Step 1: Identify the current port state.
Assume a logic analyzer shows PORTD is currently reading 11001010 (Pins 7, 6, 3, and 1 are HIGH).

Step 2: Set Pins 5 and 2 HIGH using Bitwise OR (|).
To force specific bits HIGH without touching the rest, you OR the current state with a mask containing 1s only at your target positions. Pin 5 is 00100000 (0x20) and Pin 2 is 00000100 (0x04). Combined, the mask is 00100100.

  11001010  (Current PORTD)
| 00100100  (Mask for Pins 5 & 2)
----------
  11101110  (New state: Pins 5, 3, 2, 1 are HIGH)

Step 3: Force Pin 3 LOW using Bitwise AND (&) and NOT (~).
To force a bit LOW, you AND the port with a mask that has a 0 at the target bit and 1s everywhere else. Pin 3 is 00001000. Applying the NOT operator (~) flips it to 11110111.

  11101110  (State from Step 2)
& 11110111  (NOT mask for Pin 3)
----------
  11100110  (Final state: Pin 3 is now LOW)

In embedded C, this entire operation is executed in two CPU cycles:
PORTD |= 0b00100100; // Set pins 5 and 2
PORTD &= ~0b00001000; // Clear pin 3

Where You Meet Binary in Practice

You will run into raw binary and bitwise logic constantly when moving beyond basic blink sketches. Here are the three most common jobsite and bench encounters:

1. I2C Hardware Addressing

Modules like the MCP23017 I/O expander or the PCF8574 use physical pins (usually labeled A0, A1, A2) to set their I2C bus address. These pins act as a 3-bit binary number appended to a base address. If the base address is 0x20 (00100000) and you wire A2=HIGH, A1=LOW, A0=HIGH, the binary offset is 101 (Decimal 5). The final address becomes 0x25. Understanding this prevents you from blindly running I2C scanner scripts when a sensor simply has the wrong jumper configuration.

2. Shift Registers (74HC595)

When expanding output pins via SPI or bit-banging, shift registers take serial binary data and output it in parallel. The shiftOut() function pushes bits one by one. If you need to turn on the 4th and 8th relays on an 8-channel board, you don't send decimal "136"; you conceptually send 10001000 (0x88), shifting out the Most Significant Bit (MSB) first.

3. DMX512 and Industrial DIP Switches

Lighting controllers and industrial PLC input cards use 9-pin or 10-pin DIP switches to set device addresses. These are pure binary representations. Switch 1 represents 1, Switch 2 represents 2, Switch 3 represents 4, and so on. To set a DMX address of 45, you flip Switch 6 (32), Switch 4 (8), Switch 3 (4), and Switch 1 (1). 32 + 8 + 4 + 1 = 45.

Common Confusions: Hex, BCD, and 7-Bit I2C

Binary-Coded Decimal (BCD): Often found in real-time clock (RTC) modules like the DS3231. In pure binary, decimal 25 is 00011001. In BCD, the number is split into two nibbles: the tens digit (2) and the ones digit (5), resulting in 00100101 (0x25). If you read a BCD register and treat it as pure binary, your time calculations will drift wildly.

The 7-Bit vs. 8-Bit I2C Trap: The I2C specification defines addresses as 7-bit, meaning the maximum address is 127 (01111111). However, many legacy datasheets (and some silicon vendors) list the address as an 8-bit byte, where the 8th bit is the Read/Write flag. If a datasheet claims the address is 0xA0 (10100000), the actual 7-bit address you pass to the Arduino Wire library is 0x50 (shifted right by one bit). Always consult the NXP I2C-bus specification to verify how the vendor formats their addressing tables.

Frequently Asked Questions (Binary Cheat Sheet)