AND for masking bits in Embedded C - Step-by-Step Execution

Concept Flow - AND for masking bits

Start with number

↓

Apply AND mask

↓

Result keeps bits where mask=1

↓

Result clears bits where mask=0

↓

Use result as needed

↓

End

This flow shows how applying an AND mask keeps certain bits and clears others in a number.

Execution Sample

Embedded C

unsigned char num = 0b11010110;
unsigned char mask = 0b00001111;
unsigned char result = num & mask;
// result keeps lower 4 bits of num

This code uses AND to keep only the lower 4 bits of num, clearing the upper bits.

Execution Table

Step	num (binary)	mask (binary)	Operation	Result (binary)	Result (decimal)
1	11010110	00001111	num & mask	00000110	6
2	N/A	N/A	Use result	00000110	6

💡 Finished applying AND mask; bits where mask=0 are cleared.

Variable Tracker

Variable	Start	After AND	Final
num	11010110 (214)	11010110 (214)	11010110 (214)
mask	00001111 (15)	00001111 (15)	00001111 (15)
result	N/A	00000110 (6)	00000110 (6)

Key Moments - 2 Insights

Why does the result only keep some bits of num?

Because AND with mask keeps bits only where mask has 1s (see execution_table step 1). Bits where mask is 0 become 0 in result.

What happens if mask is all zeros?

Result will be zero because AND with 0 clears all bits (not shown here but follows same logic).

Visual Quiz - 3 Questions

Look at the execution_table step 1, what is the decimal value of the result?

A 214

B 6

C 15

D 110

💡 Hint

Check the 'Result (decimal)' column in execution_table step 1.

At which step does the AND operation happen?

A Step 1

B Before Step 1

C Step 2

D No AND operation

💡 Hint

Look at the 'Operation' column in execution_table.

If mask was 0b11110000 instead, what bits of num would be kept?

A All bits

B Lower 4 bits

C Upper 4 bits

D No bits

💡 Hint

Mask bits with 1 keep those bits in num (see concept_flow).

Concept Snapshot

AND for masking bits:
- Use & operator between number and mask
- Bits where mask=1 stay same
- Bits where mask=0 become 0
- Useful to extract or clear bits
- Example: result = num & mask;

Full Transcript

This example shows how to use the AND operator to mask bits in embedded C. We start with a number and a mask. The mask has 1s where we want to keep bits and 0s where we want to clear bits. Applying AND between the number and mask keeps bits where mask is 1 and clears others. For example, num = 0b11010110 and mask = 0b00001111 results in 0b00000110, keeping only the lower 4 bits. This technique is useful to extract parts of a number or clear unwanted bits.

Practice

1. What does the bitwise AND operation with a mask do in embedded C?

easy

A. It adds the mask value to the original number.

B. It keeps only the bits where the mask has 1s and turns off others.

C. It flips all bits in the original number.

D. It shifts the bits to the left by the mask value.

Solution

1. Step 1: Understand bitwise AND with mask

   The AND operation compares each bit of two numbers and returns 1 only if both bits are 1.

2. Step 2: Apply mask logic

   Using a mask with 1s keeps those bits from the original number; 0s turn off bits.

3. Final Answer:

   It keeps only the bits where the mask has 1s and turns off others. -> Option B

4. Quick Check:

   AND with mask = keep bits [OK]

Hint: Mask with 1 keeps bits; 0 clears bits [OK]

Common Mistakes:

• Thinking AND flips bits
• Confusing AND with addition
• Assuming AND shifts bits

2. Which of the following is the correct syntax to mask the lower 4 bits of a variable val in embedded C?

easy

A. val & 0xF

B. val | 0xF

C. val << 4

D. val ^ 0xF

Solution

1. Step 1: Identify mask for lower 4 bits

   Lower 4 bits mask is 0xF (binary 00001111).

2. Step 2: Apply bitwise AND syntax

   Use val & 0xF to keep only lower 4 bits.

3. Final Answer:

   val & 0xF -> Option A

4. Quick Check:

   AND with 0xF masks lower 4 bits [OK]

Hint: Use & with 0xF to keep lower 4 bits [OK]

Common Mistakes:

• Using OR instead of AND
• Using XOR which toggles bits
• Using shift instead of mask

3. What is the output of the following code?

unsigned char val = 0xAB;  // 10101011 in binary
unsigned char mask = 0x0F; // 00001111 in binary
unsigned char result = val & mask;
printf("%02X", result);

medium

A. 0B

B. AF

C. 0A

D. AB

Solution

1. Step 1: Convert values to binary

   val = 10101011, mask = 00001111.

2. Step 2: Perform bitwise AND

   10101011 & 00001111 = 00001011 (binary) = 0x0B (hex).

3. Final Answer:

   0B -> Option A

4. Quick Check:

   AND keeps lower 4 bits = 0B [OK]

Hint: AND keeps bits where mask is 1 [OK]

Common Mistakes:

• Reading hex incorrectly
• Confusing mask bits
• Assuming output is original val

4. The following code is intended to mask the upper 4 bits of val, but it does not work as expected. What is the error?

unsigned char val = 0xAB;  // 10101011
unsigned char mask = 0xF0; // 11110000
unsigned char result = val | mask;
printf("%X", result);

medium

A. Mask value is incorrect

B. Missing parentheses around expression

C. Variable types are wrong

D. Using OR (|) instead of AND (&) for masking

Solution

1. Step 1: Understand masking operation

   Masking to keep bits requires AND (&), not OR (|).

2. Step 2: Identify incorrect operator

   The code uses OR which sets bits instead of masking.

3. Final Answer:

   Using OR (|) instead of AND (&) for masking -> Option D

4. Quick Check:

   Masking needs AND, not OR [OK]

Hint: Mask bits with & not | [OK]

Common Mistakes:

• Using OR instead of AND
• Changing mask value unnecessarily
• Assuming parentheses fix bitwise errors

5. You have a 16-bit sensor data stored in uint16_t data. The upper 8 bits represent temperature, and the lower 8 bits represent humidity. How do you extract only the temperature value using AND masking?

hard

A. temperature = (data | 0xFF00) >> 8;

B. temperature = data & 0x00FF;

C. temperature = (data & 0xFF00) >> 8;

D. temperature = data >> 8;

Solution

1. Step 1: Identify mask for upper 8 bits

   Upper 8 bits mask is 0xFF00 (binary 11111111 00000000).

2. Step 2: Apply AND and shift right

   Use (data & 0xFF00) to keep upper bits, then shift right 8 to get value.

3. Final Answer:

   temperature = (data & 0xFF00) >> 8; -> Option C

4. Quick Check:

   Mask upper 8 bits and shift right [OK]

Hint: Mask upper bits with 0xFF00 then shift right 8 [OK]

Common Mistakes:

• Masking lower bits instead
• Using OR instead of AND
• Forgetting to shift after masking