XOR for toggling bits in Embedded C - Mini Project: Build & Apply

XOR for toggling bits

📖 Scenario: You are working with a simple embedded system that controls an LED light. The LED can be turned ON or OFF by toggling a specific bit in a control register.Using XOR is a common way to toggle bits in embedded programming.

🎯 Goal: Build a small program that toggles the 3rd bit (bit 2, counting from 0) of a byte variable called control_register using XOR.This simulates turning the LED ON or OFF by flipping the bit.

📋 What You'll Learn

Create a variable control_register with initial value 0b00001000 (decimal 8).

Create a variable toggle_mask with value 0b00000100 (decimal 4) to select the 3rd bit.

Use XOR operator to toggle the 3rd bit of control_register.

Print the value of control_register in binary after toggling.

💡 Why This Matters

🌍 Real World

Toggling bits is common in embedded systems to control hardware like LEDs, switches, and sensors efficiently.

💼 Career

Embedded software engineers often use bitwise operations like XOR to manipulate hardware registers for device control.

1

DATA SETUP: Create the control register variable

Create an unsigned 8-bit variable called control_register and set it to 0b00001000 (decimal 8).

Embedded C

// Your code here

Hint

Use uint8_t for an 8-bit unsigned variable and assign the binary value 0b00001000.

2

CONFIGURATION: Create the toggle mask

Create an unsigned 8-bit variable called toggle_mask and set it to 0b00000100 (decimal 4) to select the 3rd bit.

Embedded C

#include 
#include 

uint8_t control_register = 0b00001000;
// Your code here

Hint

The mask selects the bit to toggle. Use 0b00000100 for the 3rd bit.

3

CORE LOGIC: Toggle the bit using XOR

Use the XOR operator ^= with toggle_mask to toggle the 3rd bit of control_register.

Embedded C

#include 
#include 

uint8_t control_register = 0b00001000;
uint8_t toggle_mask = 0b00000100;

// Your code here

Hint

XOR with 1 flips the bit, XOR with 0 leaves it unchanged.

4

OUTPUT: Print the toggled control register in binary

Write a printf statement to print control_register as an 8-bit binary number using this format: "Control register: 0bXXXXXXXX\n" where XXXXXXXX is the binary representation.

Embedded C

#include 
#include 

uint8_t control_register = 0b00001000;
uint8_t toggle_mask = 0b00000100;

control_register ^= toggle_mask;

// Your code here

Hint

Use a loop to print each bit from the highest (7) to lowest (0) by shifting and masking.

Practice

1. What does the XOR operator (^) do when used to toggle bits in embedded C?

easy

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

B. It flips bits where the mask has 1s and leaves others unchanged.

C. It clears all bits to 0 regardless of the mask.

D. It sets all bits to 1 regardless of the mask.

Solution

1. Step 1: Understand XOR operation basics

   XOR flips bits where the mask bit is 1 and keeps bits unchanged where mask bit is 0.

2. Step 2: Apply to toggling bits

   Using XOR with a mask toggles only the bits set in the mask, leaving others unchanged.

3. Final Answer:

   It flips bits where the mask has 1s and leaves others unchanged. -> Option B

4. Quick Check:

   XOR toggles bits = D [OK]

Hint: XOR flips bits only where mask bits are 1 [OK]

Common Mistakes:

• Thinking XOR sets bits to 1 always
• Confusing XOR with AND or OR
• Assuming XOR shifts bits

2. Which of the following is the correct syntax to toggle the 3rd bit (bit 2) of a variable flags using XOR in embedded C?

easy

A. flags = flags ^ (1 << 2);

B. flags = flags | (1 << 2);

C. flags = flags & ~(1 << 2);

D. flags = flags << 2;

Solution

1. Step 1: Identify toggle operation syntax

   To toggle a bit, XOR (^) with a mask having 1 at that bit position is used.

2. Step 2: Check each option

   flags = flags ^ (1 << 2); uses XOR with (1 << 2) which correctly toggles bit 2. Others set, clear, or shift bits incorrectly.

3. Final Answer:

   flags = flags ^ (1 << 2); -> Option A

4. Quick Check:

   Toggle bit syntax = B [OK]

Hint: Use XOR with (1 << bit_position) to toggle bits [OK]

Common Mistakes:

• Using OR instead of XOR to toggle
• Using AND with negated mask to clear bits
• Using shift operator alone

3. What is the output of the following code snippet?

unsigned char flags = 0b00001100;
flags = flags ^ 0b00000110;
printf("0x%02X", flags);

medium

A. 0x06

B. 0x0E

C. 0x0A

D. 0x12

Solution

1. Step 1: Convert initial flags and mask to binary

   flags = 00001100 (0x0C), mask = 00000110 (0x06)

2. Step 2: Apply XOR operation bitwise

   00001100 ^ 00000110 = 00001010 (0x0A)

3. Final Answer:

   0x0A -> Option C

4. Quick Check:

   0x0C ^ 0x06 = 0x0A [OK]

Hint: XOR flips bits where mask is 1, calculate bitwise [OK]

Common Mistakes:

• Adding values instead of XORing
• Misreading binary bits
• Confusing hex output format

4. The following code is intended to toggle bit 1 of status. What is the error?

unsigned int status = 0x01;
status = status & (1 << 1);

medium

A. The code should use OR operator to toggle bits.

B. The mask should be shifted by 2, not 1.

C. The variable should be unsigned char, not unsigned int.

D. Using AND instead of XOR will clear bits instead of toggling.

Solution

1. Step 1: Analyze the operator used

   The code uses AND (&) with mask, which clears bits not set in mask instead of toggling.

2. Step 2: Identify correct operator for toggling

   XOR (^) is the correct operator to toggle bits, not AND (&).

3. Final Answer:

   Using AND instead of XOR will clear bits instead of toggling. -> Option D

4. Quick Check:

   Toggle needs XOR, not AND [OK]

Hint: Toggle bits only with XOR, AND clears bits [OK]

Common Mistakes:

• Confusing AND with XOR for toggling
• Incorrect bit shift amount
• Wrong data type assumption

5. You have a 8-bit register reg initially set to 0b10101010. You want to toggle bits 1, 3, and 5 simultaneously using XOR. Which mask should you use and what will be the final value of reg after toggling?

hard

A. Mask: 0b00101010; Final reg: 0b10000000

B. Mask: 0b01010101; Final reg: 0b11111111

C. Mask: 0b00101010; Final reg: 0b10000010

D. Mask: 0b00010101; Final reg: 0b10111111

Solution

1. Step 1: Create mask for bits 1, 3, and 5

   Bits are zero-indexed from right. Bit 1 = 0b00000010, bit 3 = 0b00001000, bit 5 = 0b00100000. OR them: 0b00101010.

2. Step 2: XOR reg with mask

   reg = 0b10101010 ^ 0b00101010 = 0b10000000.

3. Final Answer:

   Mask: 0b00101010; Final reg: 0b10000000 -> Option A

4. Quick Check:

   Toggle bits 1,3,5 with mask 0x2A = 0x80 [OK]

Hint: Combine bits with OR for mask, XOR to toggle all at once [OK]

Common Mistakes:

• Wrong mask bits set
• Miscounting bit positions
• Incorrect XOR result calculation