Bitwise Operations

1. From Integers to Bits

Before we can manipulate bits, we need a clear mental model of how a number like an integer is actually stored in the computer. While you've worked with variables in Python and Java, C gives us the tools to interact with their underlying binary representation.

Let's start by reviewing how decimal numbers are represented in binary. This short video provides a clear and concise explanation.

With this binary representation in mind, C provides a specific family of operators, distinct from logical (&&, ||) or arithmetic (+, -) operators, designed to work on these bits.

2. The Bitwise Operators

Now, let's explore what each of these operators does. We'll use the same video, as it provides excellent step-by-step examples for each one.

Here's a summary table of the logical bitwise operators and a visual for the NOT operator to reinforce what you just saw.

A quick note on the NOT operator: The video mentioned that applying ~ to the number 9 resulted in -10. This is due to how C represents negative numbers using a system called Two's Complement. While fascinating, we'll focus on bitwise operations with unsigned integers for now to keep the concepts clear. The core mechanic of ~ is simply to flip all the bits.

3. Why This Matters: Safe Hardware Control

You might be wondering, "When would I actually use this?" The answer is central to your goal of working with embedded systems.

Microcontrollers like the ones on Arduino boards are controlled by special memory locations called registers. Each bit within a register often acts as a switch or a setting for a specific hardware feature (e.g., turning a pin on, setting a timer mode, configuring a communication protocol).

Changing one of these features means you need to change a single bit without disturbing the others. Using a simple assignment (=) is extremely dangerous here, because it would overwrite the entire register, potentially disabling other critical hardware functions.

This is where the Read-Modify-Write pattern becomes essential. It's the standard, safe procedure for changing hardware registers:

1. Read the current value of the entire register.
2. Modify only the specific bit(s) you care about using bitwise operators.
3. Write the new, modified value back to the register.

The following resource explains this concept perfectly. It's one of the most important low-level programming patterns you will learn.

4. Hands-On Practice

Let's write a small C program to put these operators into practice and verify their behavior.

Task:

1. Create a file named bitwise_test.c.
2. In your main function, declare two unsigned char variables. An unsigned char is a common 8-bit integer type, perfect for visualizing bits.

   unsigned char a = 9;  // Binary: 00001001
   unsigned char b = 12; // Binary: 00001100
   

3. Now, calculate and print the result of each bitwise operation. For printf, you can use the %d format specifier to see the decimal result.

   
   
   
   #include <stdio.h>
   
   int main() {
       unsigned char a = 9;  // 00001001
       unsigned char b = 12; // 00001100
   
       printf("a = %d, b = %d\n", a, b);
       printf("a & b = %d\n", a & b);    // AND
       printf("a | b = %d\n", a | b);    // OR
       printf("a ^ b = %d\n", a ^ b);    // XOR
       printf("~a = %d\n", ~a);      // NOT
       printf("b << 1 = %d\n", b << 1); // Left Shift
       printf("b >> 2 = %d\n", b >> 2); // Right Shift
   
       return 0;
   }
   

4. Before you compile and run, try to predict the results yourself on paper!
   • 00001001 & 00001100 = ?
   • 00001001 | 00001100 = ?
   • And so on...
5. Compile (gcc -Wall bitwise_test.c -o bitwise_test) and run the code. Do the results match your predictions?

a = 9, b = 12
a & b = 8
a | b = 13
a ^ b = 5
~a = -10       // Wait, why is this negative?
b << 1 = 24
b >> 2 = 3

Conclusion

In this lesson, we pulled back the curtain on how integers are stored and dove into the powerful world of bitwise operations. These operators are your tools for precise, low-level control over data.

Key Takeaways:

• All data is stored in binary, and C provides operators to manipulate these bits directly.
• The six bitwise operators are:
  • & (AND): For checking or clearing bits.
  • | (OR): For setting bits.
  • ^ (XOR): For toggling or comparing bits.
  • ~ (NOT): For inverting all bits.
  • << (Left Shift): Fast multiplication by powers of 2.
  • >> (Right Shift): Fast integer division by powers of 2.
• When working with hardware registers, a simple assignment (=) is dangerous. Always use the Read-Modify-Write pattern to safely change specific bits while preserving others.

Next Up

You've now learned the operators—the "verbs" of bit manipulation. In our next lesson, we will learn the "grammar." We will focus on combining these operators with bitmasks to reliably set, clear, and test individual bits in a variable. This technique is the foundation for implementing flag systems, controlling hardware, and writing highly efficient, memory-conscious code.