Register bit manipulation patterns in Embedded C - Step-by-Step Execution

Concept Flow - Register bit manipulation patterns

Start with Register Value

↓

Choose Bit Position

↓

Select Operation

↓

Set Bit

↓

Update Register with New Value

↓

End

This flow shows how to pick a bit in a register and either set, clear, or toggle it, then update the register.

Execution Sample

Embedded C

uint8_t reg = 0b00001100;
uint8_t bit_pos = 2;
reg |= (1 << bit_pos); // Set bit 2
reg &= ~(1 << 3);      // Clear bit 3
reg ^= (1 << 0);       // Toggle bit 0

This code sets bit 2, clears bit 3, and toggles bit 0 of an 8-bit register.

Execution Table

Step	Operation	Bit Position	Register Before	Mask Used	Register After	Explanation
1	Set Bit	2	00001100	00000100	00001100	Bit 2 is already set, register unchanged
2	Clear Bit	3	00001100	11110111	00000100	Bit 3 cleared from 1 to 0
3	Toggle Bit	0	00000100	00000001	00000101	Bit 0 toggled from 0 to 1
4	End	-	00000101	-	-	All operations done, final register value

💡 All bit manipulation operations completed on the register.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
reg	00001100	00001100	00000100	00000101	00000101
bit_pos	2	2	2	2	2

Key Moments - 3 Insights

Why does setting bit 2 not change the register in step 1?

Because bit 2 was already 1 in the register before step 1, so OR with 1<<2 keeps it the same (see execution_table row 1).

Why do we use ~(1 << bit_pos) to clear a bit?

Because ~(1 << bit_pos) creates a mask with all bits 1 except the target bit 0, so ANDing clears that bit (see execution_table row 2).

How does toggling a bit work with XOR?

XOR with 1 flips the bit: 0 becomes 1, 1 becomes 0. Here, toggling bit 0 changed it from 0 to 1 (see execution_table row 3).

Visual Quiz - 3 Questions

Look at the execution table, what is the register value after clearing bit 3?

A 00000000

B 00001100

C 00000100

D 00000101

💡 Hint

Check execution_table row 2 under 'Register After' column.

At which step does the register change from 00000100 to 00000101?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at execution_table rows 3 and 4 for register values.

If we toggle bit 2 instead of bit 0 in step 3, what would the register be after step 3?

A 00000000

B 00000101

C 1

D -1

💡 Hint

Toggling bit 2 flips bit 2 from 1 to 0 on register 00000100 (see variable_tracker).

Concept Snapshot

Register bit manipulation patterns:
- Set bit: reg |= (1 << pos)
- Clear bit: reg &= ~(1 << pos)
- Toggle bit: reg ^= (1 << pos)
Use masks to change only one bit without affecting others.
Common in embedded C for hardware control.

Full Transcript

This lesson shows how to change individual bits in a register using bitwise operations. We start with a register value and pick a bit position. To set a bit, we OR the register with a mask that has 1 at that bit. To clear a bit, we AND with a mask that has 0 at that bit and 1s elsewhere. To toggle a bit, we XOR with a mask that has 1 at that bit. The execution table traces each step showing register values before and after each operation. Key moments explain why masks work and how bits change. The quiz tests understanding of register values at each step. This is essential for embedded programming to control hardware bits safely and efficiently.

Practice

1. Which bitwise operator is used to set a specific bit in a register without changing other bits?
Example: Set bit 3 in register REG

easy

A. Bitwise OR (|)

B. Bitwise AND (&)

C. Bitwise XOR (^)

D. Bitwise NOT (~)

Solution

1. Step 1: Understand setting a bit

   Setting a bit means making that bit 1 without changing others.

2. Step 2: Use bitwise OR

   Bitwise OR with 1 at the target bit sets it to 1, others stay same.

3. Final Answer:

   Bitwise OR (|) -> Option A

4. Quick Check:

   Set bit = OR [OK]

Hint: Use OR (|) to set bits without changing others [OK]

Common Mistakes:

• Using AND (&) to set bits (it clears bits)
• Using XOR (^) which toggles bits
• Using NOT (~) which inverts all bits

2. Which of the following C code snippets correctly clears bit 2 of a register named REG?

easy

A. REG = REG | (1 << 2);

B. REG = REG << 2;

C. REG = REG ^ (1 << 2);

D. REG = REG & ~(1 << 2);

Solution

1. Step 1: Understand clearing a bit

   Clearing means setting the bit to 0 without changing others.

2. Step 2: Use AND with NOT mask

   AND with NOT of (1 shifted to bit 2) clears bit 2.

3. Final Answer:

   REG = REG & ~(1 << 2); -> Option D

4. Quick Check:

   Clear bit = AND with NOT mask [OK]

Hint: Clear bits with AND and NOT mask (~) [OK]

Common Mistakes:

• Using OR (|) which sets bits
• Using XOR (^) which toggles bits
• Using shift (<<) alone which moves bits

3. Given REG = 0b00001100;, what is the value of REG after executing REG ^= (1 << 3);?

medium

A. 0b00001100

B. 0b00000100

C. 0b00011100

D. 0b00001000

Solution

1. Step 1: Understand XOR toggling

   XOR toggles the bit: if 1 becomes 0, if 0 becomes 1.

2. Step 2: Toggle bit 3 of REG

   Bit 3 is currently 1 (0b00001100). Toggling it changes it to 0, so REG becomes 0b00000100.

3. Final Answer:

   0b00000100 -> Option B

4. Quick Check:

   XOR toggles bit 3 from 1 to 0 [OK]

Hint: XOR (^) flips bits: 1->0 or 0->1 [OK]

Common Mistakes:

• Thinking XOR sets bit instead of toggling
• Confusing bit positions (count from 0)
• Not converting binary correctly

4. What is wrong with this code to check if bit 4 of REG is set?

if (REG & (1 << 4) == 1) {
  // bit 4 is set
}

medium

A. The comparison '== 1' is incorrect; it should check if result is non-zero.

B. The shift operator '<<' is used wrongly; it should be '>>'.

C. The bit number 4 is out of range for an 8-bit register.

D. The code should use OR (|) instead of AND (&) to check bits.

Solution

1. Step 1: Understand bit check expression

   REG & (1 << 4) returns non-zero if bit 4 is set, zero if not.

2. Step 2: Fix comparison

   Comparing to 1 is wrong because bit 4 corresponds to value 16, not 1. Should check if result != 0.

3. Final Answer:

   The comparison '== 1' is incorrect; it should check if result is non-zero. -> Option A

4. Quick Check:

   Check bits by testing non-zero result [OK]

Hint: Check bits by testing if (REG & mask) != 0 [OK]

Common Mistakes:

• Comparing bit check result to 1 instead of non-zero
• Using shift right (>>) instead of left (<<)
• Using OR (|) to check bits which sets bits

5. You want to toggle bits 0, 2, and 5 of an 8-bit register REG simultaneously. Which code correctly does this?

hard

A. REG = REG & ~( (1 << 0) | (1 << 2) | (1 << 5) );

B. REG = REG | ( (1 << 0) & (1 << 2) & (1 << 5) );

C. REG ^= (1 << 0) | (1 << 2) | (1 << 5);

D. REG ^= (1 << 1) | (1 << 3) | (1 << 5);

Solution

1. Step 1: Understand toggling multiple bits

   Toggling means flipping bits. XOR (^) with mask flips bits where mask has 1.

2. Step 2: Create mask for bits 0, 2, and 5

   Mask is (1<<0) | (1<<2) | (1<<5) which sets bits 0, 2, and 5 to 1.

3. Step 3: Apply XOR with mask

   REG ^= mask flips those bits simultaneously.

4. Final Answer:

   REG ^= (1 << 0) | (1 << 2) | (1 << 5); -> Option C

5. Quick Check:

   Toggle bits with XOR and combined mask [OK]

Hint: Toggle multiple bits with XOR and combined mask [OK]

Common Mistakes:

• Using AND with NOT mask which clears bits
• Using AND (&) instead of OR (|) to combine masks
• Using wrong bit positions in mask