12. Bit Spreading Interleave Bits with Zeros
In some protocols or hardware applications (e.g. graphic rendering, signal encoding), bit spreading or interleaving is used to insert 0s between the bits of a value for purposes like data alignment or transmission.
You are given an 8-bit number, and your task is to:
- Spread the bits such that each bit is followed by a 0
- The result will be a 16-bit number where each original bit occupies even positions (0, 2, 4…)
- All odd positions are 0s
Example Logic
Original (8-bit):
b7 b6 b5 b4 b3 b2 b1 b0Spreading result (16-bit):
0 b7 0 b6 0 b5 0 b4 0 b3 0 b2 0 b1 0 b0
Example-1
Input: val = 0b11001010 (Decimal 202)
Output: 0b0101000001000100 → Decimal: 20548Example-2
Input: val = 0b10101010
Output: 0b0100010001000100 → Decimal: 17476Example-3
Input: val = 0b11111111
Output: 0b0101010101010101 → Decimal: 21845
In C, bitwise operations allow direct manipulation of individual bits within a byte, word, or register. These operations are performed using the following operators:
- | → Bitwise OR — typically used to set a bit
- & → Bitwise AND — used to clear or check a bit
- ^ → Bitwise XOR — used to toggle (invert) a bit
- ~ → Bitwise NOT — used to flip all bits (1 to 0, 0 to 1)
- <<, >> → Bit shift left/right — used to move bit positions
Common bit-masking patterns:
reg |= (1 << n); // Set bit n
reg &= ~(1 << n); // Clear bit n
reg ^= (1 << n); // Toggle bit n
if (reg & (1 << n)) // Check if bit n is setThese operations are used to target and modify only specific bits, without disturbing others.
8-bit Visualization Example
| Bit | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
|---|---|---|---|---|---|---|---|---|
| Value | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
E.g.
- To set bit 3 →
reg |= (1 << 3) - To clear bit 6 →
reg &= ~(1 << 6) - To check bit 0 →
reg & (1 << 0) - To toggle but 3 →
reg ^= (1 << 3)
32-bit Register Usage
Bitwise techniques apply the same way for uint32_t types — often used in 32-bit MCUs for status/configuration registers.
Example:
ctrl_reg |= (1U << 23); // Set bit 23 in a 32-bit control register
Common Pitfalls (Practical Tips)
- Forgetting parentheses:
1 << nmust be inside parentheses during masking:
✅reg |= (1 << 4)vs ❌reg |= 1 << 4 & 0xF - Using signed types: Never use int for register work — use
uint8_t, uint16_t, or uint32_t.
Signed values may cause undefined behavior when shifting, as MSB (Most Significant Bit) used for sign. - Wrong shift width: Shifting more than the data type width (e.g. 1 << 32 on a 32-bit int) is undefined.
- Accidental overwrite:
reg = (1 << 2); // WRONG: overwrites entire register
reg |= (1 << 2); // RIGHT: sets only the 2nd bit- Check before toggle: Be careful when toggling flags — you may unintentionally clear a set flag.
Relevance in Embedded/Firmware
- All MCU peripherals are controlled via register bits — timers, GPIOs, UART, ADC, interrupts, etc.
- Bit masking ensures safe modification without overwriting unrelated fields.
- Used in flags, control masks, interrupt status checks, and power/clock configuration.