Clearing a specific bit in a register in Embedded C - Step-by-Step Execution

Concept Flow - Clearing a specific bit in a register

Start with register value

↓

Create mask with 1 at bit position

↓

Invert mask to have 0 at bit position

↓

AND register with inverted mask

↓

Result: bit cleared, others unchanged

↓

End

We create a mask with a 1 at the bit to clear, invert it, then AND with the register to clear that bit.

Execution Sample

Embedded C

unsigned char reg = 0b11111111;
unsigned char bit = 4;
reg &= ~(1 << bit);

This code clears bit 4 of the register reg.

Execution Table

Step	Action	Value/Expression	Result
1	Initial register value	reg	0b11111111 (255 decimal)
2	Bit to clear	bit	4
3	Create mask with 1 at bit 4	1 << bit	0b00010000 (16 decimal)
4	Invert mask	~(1 << bit)	0b11101111 (239 decimal)
5	AND register with inverted mask	reg & 0b11101111	0b11111111 & 0b11101111 = 0b11101111 (239 decimal)
6	Assign result back to reg	reg &= ~(1 << bit)	reg = 0b11101111 (239 decimal)
7	Check if bit 4 cleared	bit 4 of reg	0 (cleared)
8	Exit	No more steps	Bit cleared successfully

💡 Bit 4 cleared by ANDing with inverted mask, execution ends.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
reg	0b11111111	0b11111111	0b11111111	0b11101111	0b11101111
bit	4	4	4	4	4
mask	N/A	0b00010000	0b11101111	N/A	N/A

Key Moments - 3 Insights

Why do we invert the mask before ANDing with the register?

Inverting the mask changes the bit we want to clear from 1 to 0 and all others to 1, so when ANDed, only that bit is cleared (set to 0) while others stay the same. See execution_table step 4 and 5.

What happens if we don't invert the mask and just AND with (1 << bit)?

ANDing with (1 << bit) would clear all bits except the one we want to clear, which is wrong. We must invert the mask to keep other bits unchanged. Refer to execution_table step 5.

Why use bit shifting (1 << bit) to create the mask?

Bit shifting moves the 1 to the exact bit position we want to clear, making the mask precise. This is shown in execution_table step 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of the mask after step 3?

A 0b00010000

B 0b11101111

C 0b11111111

D 0b00001111

💡 Hint

Check the 'Value/Expression' column at step 3 in execution_table.

At which step does the register get updated with the cleared bit?

A Step 5

B Step 6

C Step 3

D Step 7

💡 Hint

Look for the step where reg is assigned the new value in execution_table.

If we change bit from 4 to 3, how would the mask at step 3 change?

A 0b00000100

B 0b00010000

C 0b00001000

D 0b00000010

💡 Hint

Recall that 1 << bit shifts 1 left by bit positions; see variable_tracker mask values.

Concept Snapshot

Clearing a bit in a register:
Use mask = 1 << bit_position
Invert mask: ~mask
AND register with inverted mask: reg &= ~mask
This clears only the target bit, others stay unchanged.

Full Transcript

This visual trace shows how to clear a specific bit in a register using bitwise operations. We start with a register value and a bit position to clear. We create a mask by shifting 1 to the bit position, then invert it to have 0 at that bit and 1 elsewhere. ANDing the register with this inverted mask clears the target bit while keeping others unchanged. The execution table walks through each step with values, and the variable tracker shows how variables change. Key moments clarify why inversion is needed and how shifting works. The quiz tests understanding of mask creation, register update, and bit position changes.

Practice

1. What does the expression register &= ~(1 << 3); do in embedded C?

easy

A. Sets the 3rd bit of the register to 1

B. Clears the 3rd bit of the register (sets it to 0) without changing other bits

C. Toggles the 3rd bit of the register

D. Clears all bits of the register

Solution

1. Step 1: Understand bit shifting and negation

   The expression 1 << 3 shifts 1 to the left by 3 bits, creating a mask with only the 3rd bit set (00001000).

2. Step 2: Apply bitwise NOT and AND assignment

   The bitwise NOT ~(1 << 3) flips all bits, making the 3rd bit 0 and others 1. ANDing this with the register clears only the 3rd bit.

3. Final Answer:

   Clears the 3rd bit of the register (sets it to 0) without changing other bits -> Option B

4. Quick Check:

   Clear bit 3 = register &= ~(1 << 3) [OK]

Hint: Use AND with NOT mask to clear a bit [OK]

Common Mistakes:

• Confusing clearing with setting a bit
• Using OR instead of AND
• Not applying bitwise NOT before AND

2. Which of the following is the correct syntax to clear bit 5 of a variable named reg?

easy

A. reg &= ~(1 << 5);

B. reg |= ~(1 << 5);

C. reg = reg & (1 << 5);

D. reg = reg | (1 << 5);

Solution

1. Step 1: Identify the operation to clear a bit

   Clearing a bit means setting it to 0. This is done by ANDing with the negation of the bit mask.

2. Step 2: Check each option's operation

   reg &= ~(1 << 5); uses &= ~(1 << 5), which correctly clears bit 5. Others either set or incorrectly manipulate bits.

3. Final Answer:

   reg &= ~(1 << 5); -> Option A

4. Quick Check:

   Clear bit 5 = reg &= ~(1 << 5) [OK]

Hint: Clear bit with AND and NOT mask [OK]

Common Mistakes:

• Using OR (|) instead of AND (&)
• Forgetting to negate the mask
• Assigning instead of using compound assignment

3. Given unsigned char reg = 0b11111111; and the operation reg &= ~(1 << 2);, what is the binary value of reg after execution?

medium

A. 0b11111011

B. 0b11111101

C. 0b11110111

D. 0b11111110

Solution

1. Step 1: Identify the bit to clear

   Bit 2 means the third bit from the right (0-based index). The mask is 1 << 2 = 0b00000100.

2. Step 2: Apply clearing operation

   Negate mask: ~0b00000100 = 0b11111011. AND with reg: 0b11111111 & 0b11111011 = 0b11111011.

3. Final Answer:

   0b11111011 -> Option A

4. Quick Check:

   Clear bit 2 from 0xFF = 0xFB (binary 11111011) [OK]

Hint: Clear bit 2 flips that bit to 0 only [OK]

Common Mistakes:

• Clearing wrong bit index
• Not negating the mask
• Confusing bit positions (1-based vs 0-based)

4. What is wrong with this code snippet if the goal is to clear bit 4 of reg?

reg = reg & (1 << 4);

medium

A. It causes a syntax error

B. It correctly clears bit 4

C. It sets all bits except bit 4 to 0, not clearing bit 4

D. It toggles bit 4 instead of clearing

Solution

1. Step 1: Analyze the operation performed

   The expression reg & (1 << 4) keeps only bit 4 and clears all others, effectively zeroing all bits except bit 4.

2. Step 2: Compare with correct clearing method

   To clear bit 4, we must AND with the negation of the mask: reg &= ~(1 << 4);. The given code does not do this.

3. Final Answer:

   It sets all bits except bit 4 to 0, not clearing bit 4 -> Option C

4. Quick Check:

   AND with mask keeps only that bit [OK]

Hint: AND with mask keeps only that bit, not clears it [OK]

Common Mistakes:

• Using AND with mask instead of negated mask
• Confusing clearing with masking
• Expecting toggling behavior

5. You have a 16-bit register uint16_t reg = 0xFFFF;. You want to clear bits 0, 4, and 15 simultaneously. Which code correctly does this?

hard

A. reg |= ( (1 << 0) | (1 << 4) | (1 << 15) );

B. reg &= ( (1 << 0) | (1 << 4) | (1 << 15) );

C. reg |= ~( (1 << 0) | (1 << 4) | (1 << 15) );

D. reg &= ~( (1 << 0) | (1 << 4) | (1 << 15) );

Solution

1. Step 1: Create a mask for bits to clear

   Bits 0, 4, and 15 correspond to masks 1<<0, 1<<4, and 1<<15. OR them to combine: (1<<0) | (1<<4) | (1<<15).

2. Step 2: Negate mask and AND with register

   Negate the combined mask to get zeros at bits 0,4,15 and ones elsewhere. AND with reg clears those bits.

3. Final Answer:

   reg &= ~( (1 << 0) | (1 << 4) | (1 << 15) ); -> Option D

4. Quick Check:

   Clear multiple bits by AND with negated OR mask [OK]

Hint: Combine bits with OR, negate, then AND to clear multiple bits [OK]

Common Mistakes:

• Using OR instead of AND to clear bits
• Not negating the combined mask
• Clearing only one bit instead of all three