AND for masking bits in Embedded C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the AND operator (&) do when used for masking bits in embedded C?

The AND operator (&) keeps bits set to 1 only if both bits in the operands are 1. It is used to isolate specific bits by masking others to 0.

beginner

How do you use AND to check if a specific bit is set in a byte?

Use AND with a mask that has 1 only at the bit position you want to check. If the result is not zero, the bit is set.

beginner

Example: What is the result of 0b1101 & 0b0100 in binary?

0b0100 (which is 4 in decimal). Only the third bit is kept because the mask has 1 there.

intermediate

Why is AND masking useful in embedded programming?

It allows you to read or clear specific bits in hardware registers without changing other bits.

beginner

What happens if you AND a number with 0xFF?

The number stays the same because 0xFF has all bits set to 1 in the lowest 8 bits, so no bits are masked out.

What does the expression (value & 0x01) check in embedded C?

A If value is zero

B If the most significant bit of value is set

C If all bits of value are set

D If the least significant bit of value is set

0x01 has only the least significant bit set to 1, so ANDing with it checks that bit.

What is the result of 0b1010 & 0b1100?

A 0b1110

B 0b0110

C 0b1000

D 0b0010

Only bits set in both numbers remain 1; here, only the bit at position 3 is 1 in both.

Which mask would you use to isolate the 4th bit (bit 3) of a byte?

A 0x08

B 0x04

C 0x10

D 0x01

0x08 in hex is 00001000 in binary, which corresponds to bit 3.

If you want to clear all bits except bit 2, which operation would you use?

A value ^ 0x04

B value & 0x04

C value | 0x04

D value & 0xFB

AND with 0x04 keeps only bit 2 and clears others.

What does ANDing a number with zero do?

A Always results in zero

B Keeps the number unchanged

C Inverts the bits

D Sets all bits to 1

AND with zero clears all bits, so the result is always zero.

Explain how the AND operator is used to mask bits in embedded C.

Think about how you keep some bits and clear others.

Describe a real-life example where masking bits with AND is useful in embedded programming.

Imagine reading a button press or sensor status.

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