OR for setting bits in Embedded C - Deep Dive

Overview - OR for setting bits

What is it?

OR for setting bits is a way to turn specific bits in a number to 1 without changing the other bits. It uses the OR operation, which compares two numbers bit by bit and sets the result bit to 1 if either bit is 1. This is useful in embedded programming to control hardware settings or flags by turning on certain bits.

Why it matters

Without this method, changing bits would be complicated and error-prone, requiring manual checks and changes for each bit. OR for setting bits makes it easy and safe to turn on specific features or options in devices, ensuring other settings stay unchanged. This helps prevent bugs and hardware misbehavior in real devices.

Where it fits

Before learning this, you should understand binary numbers and basic bitwise operations like AND, OR, and NOT. After this, you can learn about clearing bits with AND, toggling bits with XOR, and using bit masks for more complex control.

Mental Model

Core Idea

Using OR with a mask sets chosen bits to 1 while leaving all other bits unchanged.

Think of it like...

Imagine a light switch panel where each switch controls a light. Using OR to set bits is like flipping only the switches you want ON without touching the others.

Original:  0 1 0 0 1 0 1 0
Mask:      0 0 1 0 0 1 0 0
--------------------------
Result:    0 1 1 0 1 1 1 0

Build-Up - 6 Steps

1

Foundation

Understanding bits and binary numbers

Concept: Learn what bits are and how numbers are represented in binary.

A bit is a single 0 or 1. Numbers in computers are stored as sequences of bits. For example, the number 10 in binary is 00001010 (8 bits). Each position represents a power of two.

Result

You can read and write numbers in binary, understanding each bit's place value.

Knowing bits and binary is essential because bitwise operations work directly on these bits.

2

Foundation

Basics of bitwise OR operation

Concept: Learn how the OR operation works on two bits and extends to numbers.

OR compares two bits: if either bit is 1, the result is 1; otherwise, 0. For example, 0 OR 1 = 1, 0 OR 0 = 0. When applied to numbers, OR works bit by bit.

Result

You can predict the result of OR between two binary numbers.

Understanding OR at the bit level helps you see how it can set bits to 1.

3

Intermediate

Using OR to set specific bits

🤔Before reading on: do you think OR can turn off bits as well as turn them on? Commit to your answer.

Concept: Using a mask with OR sets bits to 1 where the mask has 1s, leaving other bits unchanged.

To set bits, create a mask with 1s in the positions you want to set. Then OR the original number with this mask. For example, to set bit 2 (counting from 0), use mask 00000100 and OR it with your number.

Result

Bits in the original number at mask positions become 1; others stay the same.

Knowing OR only sets bits to 1 prevents accidental clearing of bits and helps control hardware flags safely.

4

Intermediate

Creating and applying bit masks

🤔Before reading on: do you think a mask can have multiple bits set at once? Commit to your answer.

Concept: Masks can have multiple bits set to 1 to set several bits at once using OR.

For example, mask 00001100 sets bits 2 and 3. Applying OR with this mask sets both bits in the original number. You can combine bits by adding their powers of two: 4 + 8 = 12 (00001100).

Result

Multiple bits are set simultaneously in the original number.

Understanding masks as sums of powers of two allows flexible control over multiple bits.

5

Advanced

Using OR in embedded hardware control

🤔Before reading on: do you think setting bits with OR can accidentally change other hardware settings? Commit to your answer.

Concept: OR is used to set control bits in hardware registers without affecting other bits.

Hardware devices often use registers where each bit controls a feature. Using OR with a mask sets only desired bits, leaving others intact. For example, setting a pin as output or enabling a peripheral.

Result

Hardware features are enabled safely without disturbing unrelated settings.

Knowing OR preserves other bits prevents hardware bugs caused by unintended changes.

6

Expert

Common pitfalls and atomicity in bit setting

🤔Before reading on: do you think OR operations are always safe in multi-threaded or interrupt-driven code? Commit to your answer.

Concept: In concurrent environments, OR operations may need protection to avoid race conditions.

If two processes try to set bits simultaneously, one might overwrite the other's changes. Using atomic operations or disabling interrupts during bit setting ensures safe updates.

Result

Bit settings remain consistent and no bits are lost due to concurrency.

Understanding concurrency issues with OR operations is crucial for reliable embedded system design.

Under the Hood

The OR operation compares each bit of two binary numbers. For each bit position, if either input bit is 1, the output bit is set to 1. This is done by the processor's ALU (Arithmetic Logic Unit) using simple logic gates. When setting bits, the mask has 1s where bits should be set, so OR forces those bits to 1 in the result, while bits with 0 in the mask remain unchanged.

Why designed this way?

OR was designed as a simple, fast bitwise operation that can combine bits without clearing any. This makes it ideal for setting bits safely. Alternatives like AND clear bits, so OR complements them. The design balances simplicity, speed, and control, essential for low-level hardware programming.

Input A:  0 1 0 1 0 0 1 0
Mask B:   0 0 1 0 1 0 0 1
-------------------------
Result:   0 1 1 1 1 0 1 1

Myth Busters - 3 Common Misconceptions

Quick: Does OR operation ever clear bits from 1 to 0? Commit to yes or no.

Common Belief: OR can both set and clear bits depending on the mask.

Reality: OR can only set bits to 1; it never clears bits from 1 to 0.

Why it matters: Believing OR can clear bits leads to bugs where bits expected to be cleared remain set, causing incorrect device behavior.

Quick: If you OR a number with zero, does it change? Commit to yes or no.

Common Belief: OR with zero can change bits in the original number.

Reality: OR with zero leaves the original number unchanged because zero has no bits set.

Why it matters: Misunderstanding this wastes time debugging code that tries to 'set' bits with zero masks.

Quick: Can OR operations cause race conditions in embedded systems? Commit to yes or no.

Common Belief: Bitwise OR operations are always safe and atomic.

Reality: OR operations are not atomic on many processors; concurrent access can cause lost updates.

Why it matters: Ignoring this can cause subtle bugs in multi-threaded or interrupt-driven embedded code.

Expert Zone

1

When multiple bits need setting, combining masks with OR before applying reduces instruction count and improves efficiency.

2

Some processors provide atomic bit set instructions that internally use OR but guarantee no race conditions, which is critical in real-time systems.

3

Using OR with volatile-qualified variables requires care because compiler optimizations might reorder operations, affecting hardware timing.

When NOT to use

OR for setting bits is not suitable when you need to clear bits or toggle bits; use AND with negated masks or XOR instead. Also, in concurrent environments without atomic support, use hardware-specific atomic instructions or disable interrupts.

Production Patterns

In embedded firmware, OR is commonly used to enable hardware features by setting control register bits. It is combined with masks defined as constants or macros for readability. Often, OR operations are wrapped in functions or macros to ensure safe and clear usage.

Connections

Bitwise AND for clearing bits

Complementary operation

Understanding OR for setting bits alongside AND for clearing bits gives full control over individual bits in a number.

Atomic operations in concurrent programming

Builds-on

Knowing the limits of OR in concurrency leads to learning atomic instructions that ensure safe bit manipulation in multi-threaded systems.

Digital logic gates in electronics

Same pattern

OR operation in programming directly corresponds to OR gates in electronics, linking software bit manipulation to physical hardware behavior.

Common Pitfalls

#1 Trying to clear bits using OR operation.

Wrong approach:

uint8_t reg = 0b11110000;
reg = reg | 0b00001111; // Trying to clear lower bits but actually sets them

Correct approach:

uint8_t reg = 0b11110000;
reg = reg & 0b11110000; // Use AND with mask to clear bits

Root cause:

Misunderstanding that OR can clear bits; OR only sets bits to 1.

#2 Using OR with zero mask expecting changes.

Wrong approach:

uint8_t reg = 0b10101010;
reg = reg | 0b00000000; // No change happens

Correct approach:

uint8_t reg = 0b10101010;
reg = reg | 0b00000100; // Sets bit 2

Root cause:

Not realizing OR with zero mask leaves the number unchanged.

#3 Not protecting OR operations in interrupt-driven code.

Wrong approach:

reg = reg | 0x04; // Non-atomic update in ISR and main code

Correct approach:

Disable interrupts;
reg = reg | 0x04;
Enable interrupts; // Protect update

Root cause:

Ignoring concurrency issues causes race conditions and lost bit updates.

Key Takeaways

OR operation sets bits to 1 where the mask has 1s, leaving other bits unchanged.

Using OR with a mask is a safe and efficient way to enable features or flags in embedded systems.

OR cannot clear or toggle bits; other bitwise operations are needed for those tasks.

In concurrent or interrupt-driven environments, OR operations may require protection to avoid race conditions.

Understanding OR for setting bits is fundamental for low-level hardware control and embedded programming.