Pictures as Data: Binary, Hex, and Bit Masks

It confuses a common storage unit with the amount of information required.

A monochrome pixel has two states, and one bit has two states:

0 → off
1 → on

One bit therefore contains enough information to describe one pixel. A byte offers 256 possible patterns, far more than a single two-state pixel needs.

This tells us the theoretical information required. A language or device may organize that information in larger units, but that is a separate implementation question.

The current display contains:

128 × 64 = 8,192 pixels
8,192 pixels × 1 bit = 8,192 bits
8,192 bits ÷ 8 = 1,024 bytes

Doubling the width doubles the pixel count. Doubling the height doubles it again, so the larger frame requires four times as much memory:

256 × 128 = 32,768 bits = 4,096 bytes

Image memory grows with area. Doubling both dimensions quadruples the raw pixel data.

Bits 5, 3, 2, and 0 are on:

bit:    7 6 5 4 3 2 1 0
state:  0 0 1 0 1 1 0 1
weight:     32    8 4   1

Add only those weights:

32 + 8 + 4 + 1 = 45

Therefore 00101101₂ represents 45₁₀. The durable skill is seeing which powers of two are present, not memorizing that particular result.

Choose the largest available power of two without exceeding the remaining value:

173 = 128 + 32 + 8 + 4 + 1

Place 1 under those weights and 0 everywhere else:

weight: 128 64 32 16 8 4 2 1
state:    1  0  1  0 1 1 0 1

The byte is 10101101. Working from powers of two reinforces what every position means, which will matter when we begin targeting individual bits.

Split the binary byte into two four-bit groups, called nibbles:

0010 1101
  2    D

Each nibble becomes one hexadecimal digit, so the byte becomes 0x2D. The 0x prefix tells Python and the reader that the following digits are hexadecimal.

Hardware documentation often uses values such as 0x3C, 0x81, 0xAE, and 0xFF because they are shorter than binary while remaining easy to expand into groups of four bits.

Replace each hex digit with its four-bit group:

0xA7 → 1010 0111 → 10100111
0x3C → 0011 1100 → 00111100
0xF0 → 1111 0000 → 11110000
0x55 → 0101 0101 → 01010101

The alternating pattern in 0x55 is especially easy to recognize. Its opposite is 0xAA, or 10101010. Patterns such as 0x00, 0xFF, 0x55, and 0xAA are useful when testing hardware because their shapes are unmistakable.

They are different written representations of the same numerical value:

60            decimal
0x3C          hexadecimal
0b00111100    binary

The prefixes tell Python how to interpret the source text. They do not create three different values. This resembles writing the same quantity as 1/2, 0.5, or 50%.

Representation is how we write a value. The value is the quantity being represented.

The requested positions produce this pattern:

bit:    7 6 5 4 3 2 1 0
state:  0 1 0 0 1 0 1 0

Each shift creates one mask:

1 << 6  → 01000000
1 << 3  → 00001000
1 << 1  → 00000010

Bitwise OR combines them:

value = (1 << 6) | (1 << 3) | (1 << 1)

The result is 01001010, or 0x4A. We are no longer merely reading a pattern; we are constructing it deliberately.

The mask contains a 1 only at bit 3:

  10100001
| 00001000
  --------
  10101001

OR produces 1 when either input bit is 1. The mask’s zeroes therefore preserve every other position while its single 1 turns bit 3 on.

Python offers a shorter assignment form:

value |= 1 << 3

AND preserves a bit when the mask contains 1 and clears it when the mask contains 0. We therefore need 11011111: zero at bit 5, one everywhere else.

  11101111
& 11011111
  --------
  11001111

In Python:

value &= ~(1 << 5)

Python integers are not limited to eight bits, so ~(1 << 5) is a negative integer if printed by itself. The AND expression still clears the intended bit. When you need to display or transmit the mask as an explicit byte, keep only its low eight bits:

mask = ~(1 << 5) & 0xFF  # 0b11011111
value &= mask

Create a mask containing a 1 only at bit 2:

mask = 1 << 2

Then use AND:

  10110100
& 00000100
  --------
  00000100

The nonzero result means the bit is on. Python can test it directly:

if value & (1 << 2):
    print("bit is on")

If bit 2 were off, the result would be zero. The operation reads the selected bit without modifying value.

Addition appears to work only when bit 4 is currently zero. If it is already on, adding another 1 << 4 causes a carry:

  00010000
+ 00010000
  --------
  00100000

Bit 4 turns off and bit 5 turns on. OR behaves differently:

  00010000
| 00010000
  --------
  00010000

Arithmetic addition changes a number by a quantity. Bitwise OR combines positions according to a truth rule. Use OR when the job is to turn a selected bit on.

Each A expands to 1010:

0xAA → 10101010

If each bit controlled one physical element, the result would alternate on and off. The opposite pattern is:

01010101 → 0x55

Alternating patterns are good diagnostics. They make stuck, swapped, or unexpectedly grouped positions easier to see than an arbitrary value would.

The original pattern is:

bit:    7 6 5 4 3 2 1 0
state:  1 1 0 0 1 0 1 1

That gives:

binary:       11001011
hexadecimal:  0xCB
decimal:      128 + 64 + 8 + 2 + 1 = 203

Construct it with one shifted mask per on bit:

value = (
    (1 << 7)
    | (1 << 6)
    | (1 << 3)
    | (1 << 1)
    | (1 << 0)
)

Now clear bit 6:

value &= ~(1 << 6)

The result is 10001011, or 0x8B.