NOT for inverting bits in Embedded C - Mini Project: Build & Apply

Using NOT Operator to Invert Bits in Embedded C

📖 Scenario: You are working on a small embedded system that controls an LED display. The display uses an 8-bit register where each bit represents an LED: 1 means the LED is ON, and 0 means the LED is OFF.You want to create a program that can invert the current LED states using the NOT operator, so all ON LEDs turn OFF and all OFF LEDs turn ON.

🎯 Goal: Build a simple embedded C program that uses the NOT operator ~ to invert the bits of an 8-bit variable representing LED states.

📋 What You'll Learn

Create an 8-bit unsigned integer variable called led_state with a specific initial value.

Create a mask variable called mask to limit the bits to 8 bits.

Use the NOT operator ~ to invert the bits of led_state and apply the mask.

Print the original and inverted LED states in binary format.

💡 Why This Matters

🌍 Real World

In embedded systems, controlling hardware like LEDs often requires manipulating bits directly. Using the NOT operator to invert bits is a common task to toggle states quickly.

💼 Career

Understanding bitwise operations and how to invert bits is essential for embedded software developers working with microcontrollers, hardware registers, and low-level device control.

1

Create the initial LED state variable

Create an 8-bit unsigned integer variable called led_state and set it to 0b10101010 to represent the initial LED states.

Embedded C

# Create the variable led_state with value 0b10101010
// Your code here

Hint

Use uint8_t to create an 8-bit unsigned integer and assign the binary value 0b10101010.

2

Create a mask to limit bits to 8 bits

Create an 8-bit unsigned integer variable called mask and set it to 0xFF to mask the bits after inversion.

Embedded C

#include 
#include 

uint8_t led_state = 0b10101010;

// Create the mask variable with value 0xFF
// Your code here

Hint

The mask 0xFF keeps only the lowest 8 bits after inversion.

3

Invert the bits of led_state using NOT operator

Create an 8-bit unsigned integer variable called inverted_led_state and set it to the bitwise NOT of led_state masked with mask using ~led_state & mask.

Embedded C

#include 
#include 

uint8_t led_state = 0b10101010;
uint8_t mask = 0xFF;

// Invert led_state bits and apply mask
// Your code here

Hint

Use the bitwise NOT operator ~ on led_state and then apply the mask with & mask.

4

Print the original and inverted LED states in binary

Write two printf statements to print led_state and inverted_led_state in 8-bit binary format using a loop to show each bit.

Embedded C

#include 
#include 

uint8_t led_state = 0b10101010;
uint8_t mask = 0xFF;
uint8_t inverted_led_state = ~led_state & mask;

int main() {
    // Print led_state in binary
    // Your code here

    // Print inverted_led_state in binary
    // Your code here
    return 0;
}

Hint

Use a for loop from 7 down to 0 and print each bit by shifting and masking with 1.

Practice

1.

What does the ~ operator do in embedded C?

easy

A. It flips every bit of the operand (bitwise NOT).

B. It shifts bits to the left by one position.

C. It adds one to the operand.

D. It compares two values for equality.

Solution

1. Step 1: Understand the ~ operator

   The ~ operator is the bitwise NOT operator in C, which flips every bit of its operand.

2. Step 2: Compare with other options

   Other options describe different operations: shifting, addition, and comparison, which are not what ~ does.

3. Final Answer:

   It flips every bit of the operand (bitwise NOT). -> Option A

4. Quick Check:

   ~ operator = bitwise NOT [OK]

Hint: Remember ~ flips bits, like turning 0s to 1s and vice versa [OK]

Common Mistakes:

• Confusing ~ with shift operators
• Thinking ~ adds or subtracts
• Mixing ~ with logical NOT (!)

2.

Which of the following is the correct syntax to invert bits of an unsigned integer x in embedded C?

unsigned int x = 5;
unsigned int y = ?;

easy

A. y = x++;

B. y = !x;

C. y = ~x;

D. y = x & ~x;

Solution

1. Step 1: Identify the bit inversion syntax

   To invert bits, use the bitwise NOT operator ~ directly on the variable.

2. Step 2: Check other options for correctness

   y = !x; uses logical NOT, which returns 0 or 1, not bit inversion. y = x++; increments x, not invert bits. y = x & ~x; ANDs x with its inverse, resulting in zero.

3. Final Answer:

   y = ~x; -> Option C

4. Quick Check:

   Bit inversion syntax = y = ~x; [OK]

Hint: Use ~ directly on variable to invert bits [OK]

Common Mistakes:

• Using ! instead of ~
• Using increment operators by mistake
• Combining & with ~ incorrectly

3.

What is the output of the following code snippet?

unsigned char x = 0b00001111;
unsigned char y = ~x;
printf("%u", y);

medium

A. 240

B. 15

C. 0

D. 255

Solution

1. Step 1: Understand the initial value of x

   x is 0b00001111, which is decimal 15.

2. Step 2: Apply bitwise NOT to x

   ~x flips bits: 00001111 becomes 11110000 in 8 bits, which is decimal 240.

3. Final Answer:

   240 -> Option A

4. Quick Check:

   ~15 (8-bit) = 240 [OK]

Hint: Invert bits of 00001111 to get 11110000 = 240 decimal [OK]

Common Mistakes:

• Confusing logical NOT (!) with bitwise NOT (~)
• Forgetting unsigned type size
• Assuming output is 15 or 255

4.

Find the error in the following code that attempts to invert bits of num and print the result:

int num = 5;
int inverted = ~num;
printf("%u", inverted);

medium

A. The variable inverted should be unsigned char.

B. The ~ operator cannot be used on int types.

C. Missing semicolon after variable declaration.

D. Using %u to print a signed int causes incorrect output.

Solution

1. Step 1: Check the type and format specifier

   Variable inverted is signed int, but printed with %u (unsigned). This mismatch can cause wrong output.

2. Step 2: Verify other options

   The ~ operator works on int types. Semicolons are present. Changing to unsigned char is not necessary but can clarify output.

3. Final Answer:

   Using %u to print a signed int causes incorrect output. -> Option D

4. Quick Check:

   Format specifier must match variable type [OK]

Hint: Match printf format (%d for int, %u for unsigned) [OK]

Common Mistakes:

• Using wrong printf format specifier
• Thinking ~ can't be used on int
• Ignoring signed vs unsigned mismatch

5.

You want to invert bits of a 16-bit unsigned integer val but only for the lower 8 bits, leaving the upper 8 bits unchanged. Which code snippet correctly does this?

unsigned short val = 0xABCD;
unsigned short result = ?;

hard

A. result = ~val & 0xFFFF;

B. result = (val & 0xFF00) | (~val & 0x00FF);

C. result = ~val | 0xFF00;

D. result = val ^ 0xFFFF;

Solution

1. Step 1: Understand the requirement

   Invert only the lower 8 bits of val, keep upper 8 bits as is.

2. Step 2: Analyze each option

   result = (val & 0xFF00) | (~val & 0x00FF); keeps upper 8 bits (val & 0xFF00) and inverts lower 8 bits (~val & 0x00FF), then combines them. result = ~val & 0xFFFF; inverts all 16 bits. result = ~val | 0xFF00; incorrectly sets upper bits to 1. result = val ^ 0xFFFF; flips all bits (XOR with 0xFFFF).

3. Final Answer:

   result = (val & 0xFF00) | (~val & 0x00FF); -> Option B

4. Quick Check:

   Mask upper bits, invert lower bits, combine [OK]

Hint: Mask upper bits, invert lower bits, then combine [OK]

Common Mistakes:

• Inverting all bits instead of just lower 8
• Using OR instead of AND for masking
• Forgetting to combine masked parts