DEV Community: Hrishikesh Karande

#14 Extracting a Nibble from an 8-bit Register in C

Hrishikesh Karande — Tue, 16 Sep 2025 22:40:20 +0000

When I first saw the problem statement on EWskills “extract a nibble from an 8-bit register”, I thought this would be easy. After all, a nibble is just 4 bits, right? But along the way, I discovered I had several gaps in my understanding — not just about bit manipulation, but also about how hexadecimal numbers, masks, and C syntax really work. In this post, I’ll walk you through my confusion, how I corrected my thinking, and what I learned about firmware development in C.

The Problem

We are given:

An 8-bit register value (0–255).
A position:
- 0 means extract the lower nibble (bits 0–3).
- 1 means extract the upper nibble (bits 4–7).

We need to return the nibble value as a decimal number (0–15).

Example

Input: reg = 0xAB, pos = 0 Output: 11
Input: reg = 0xAB, pos = 1 Output: 10

At first, this confused me. Let’s unpack why.

My Initial Confusion

1. Decimal vs Hexadecimal vs Binary

Take 0xAB.

In binary: 1010 1011
In decimal: 171

When we split this into nibbles:

Upper nibble: 1010 → hex 0xA → decimal 10
Lower nibble: 1011 → hex 0xB → decimal 11

The problem statement said the output should be 11. At first, I thought this was binary 11 (which is decimal 3). That was my mistake! The expected output is in decimal, even though the register values are written in hexadecimal. Once I understood that, things became much clearer.

2. Writing the Mask

I also struggled with the mask. The statement said:

For a 3-bit field → mask = 0x07

I thought “wait, isn’t 0x07 just decimal 7? Shouldn’t it be something else?”

The reality is: yes, 0x07 is decimal 7. But in binary, it is 0000 0111. That’s exactly what we want for a 3-bit mask — the last 3 bits set to 1.

This led me to a general rule:

N-bit mask = (1 << N) – 1

Examples:

3 bits → (1 << 3) – 1 = 7 = 0x07 → 0000 0111
4 bits → (1 << 4) – 1 = 15 = 0x0F → 0000 1111
8 bits → (1 << 8) – 1 = 255 = 0xFF → 1111 1111

So for nibble extraction (4 bits), our mask should be 0x0F.

3. A Bug in My First C Code

Here’s my first attempt:

unsigned char extractNibble(unsigned char reg, int pos) {
    if (pos = 0) {                  // Oops!
        unsigned char lower = (reg >> 0) & 0x07;   
        return lower;
    } else {
        unsigned char higher = (reg >> 6) & 0x07;
        return higher;
    }
}

Mistakes I made:

if (pos = 0) → This was an assignment, not a comparison. It always evaluates to false. It should have been if (pos == 0).
My mask was 0x07 (3 bits), but a nibble is 4 bits, so it should have been 0x0F.
My upper nibble shift was >> 6, but it should have been >> 4.

The Corrected Code

Here’s the fixed version:

#include <stdio.h>

unsigned char extractNibble(unsigned char reg, int pos) {
    if (pos == 0) {
        // Lower nibble
        return reg & 0x0F;
    } else {
        // Upper nibble
        return (reg >> 4) & 0x0F;
    }
}

int main() {
    unsigned char reg;
    int pos;
    scanf("%hhu %d", &reg, &pos);
    printf("%d", extractNibble(reg, pos));
    return 0;
}

This now works for all cases:

0xAB, pos=0 → 11
0xAB, pos=1 → 10
0xFF, pos=0 → 15

Making It More "Firmware Style"

In embedded systems, we often use macros for clarity:

#define NIBBLE_MASK  0x0F
#define NIBBLE_BITS  4
#define EXTRACT_NIBBLE(reg, pos)  (((reg) >> ((pos) * NIBBLE_BITS)) & NIBBLE_MASK)

unsigned char extractNibble(unsigned char reg, int pos) {
    return EXTRACT_NIBBLE(reg, pos);
}

This eliminates the if statement, and clearly shows the relationship between position, shift, and mask.

My Key Learnings

Nibble extraction: A nibble is 4 bits, and we always mask with 0x0F after shifting.
Decimal vs Hex: Register values may be written in hex, but outputs are usually in decimal. Don’t confuse them!
Mask formula: (1 << N) – 1 is the universal way to get an N-bit mask.
C syntax trap: = vs == — a small slip that breaks logic.
Firmware style: Macros make register manipulation more readable and consistent.

Conclusion

What seemed like a simple “extract a nibble” problem actually taught me a lot about bit manipulation, number systems, and C programming pitfalls. These are the bread and butter of firmware development — almost every hardware register requires you to mask, shift, and extract fields safely.

If you’re new to embedded C, I’d recommend practicing small tasks like this. They may look trivial, but they prepare you for real-world firmware, where the difference between 0x07 and 0x0F can mean your UART or ADC doesn’t work at all.

#3 Checking the K-th Bit in C

Hrishikesh Karande — Sun, 14 Sep 2025 13:39:21 +0000

While working on this small problem on EWskill of checking whether the K-th bit of an integer is set, I learned several important lessons about C programming and firmware development. I want to walk you through my experience, step by step, as if you’re seeing it for the first time.

Understanding the Problem

The task was simple: given an integer N and a bit position K (0-based index), I had to determine if the K-th bit in the binary representation of N is 1 (set) or 0 (not set).

For example:

N = 8 → binary: 00001000
K = 3 → the 3rd bit is 1, so the output should be 1. At first glance, it seems trivial, but this problem taught me a lot about bit manipulation, efficient C coding, and embedded thinking.

The Code I wrote:

#include <stdio.h>

int isKthBitSet(int n, int k) {
    // Write your code here
    if (n & (1 << k)){
        return 1;
    } else {
        return 0;
    }
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    printf("%d", isKthBitSet(n, k));
    return 0;
}

Writing the Function Step by Step

The first version I wrote looked like this:

int isKthBitSet(int n, int k) {
    if ((n & (1 << k)) == 1){
        return 1;
    } else {
        return 0;
    }
}

Here’s what I learned while writing this:

Bitwise AND (&): This operator allows me to check specific bits in a number.
Left Shift (1 << k): This creates a mask where only the K-th bit is 1. For example, 1 << 3 becomes 00001000.
Logical comparison mistake: I realized that comparing with == 1 doesn’t work for bits other than the least significant one. For example, (8 & 8) == 1 would fail, even though the 3rd bit is set.

This taught me to always think carefully about what the bitwise operations actually return.

Making the Function Efficient

After understanding the logic, I rewrote the function in a more compact way:

int isKthBitSet(int n, int k) {
    return (n & (1 << k)) != 0;
}

Here, I learned:

In C, any non-zero value is considered true, so we don’t always need complex if-else statements.
Writing concise code is important in firmware because it saves memory and execution time.

Microcontroller-Style Firmware Thinking

Finally, I learned the “microcontroller mindset.” Firmware developers often write code that is minimal, fast, and hardware-friendly. The ultimate version of my function became:

int isKthBitSet(int n, int k) {
    return n & (1 << k);
}

No comparisons, no extra branching—just raw bitwise logic.
The result is either 0 (bit not set) or some non-zero value (bit set), which works perfectly in embedded systems.

This taught me to trust how C treats non-zero values and to think in bits rather than abstract numbers—a fundamental mindset for firmware development.

My Key Learnings

Bit manipulation is powerful: It lets you control hardware directly and efficiently.
C is flexible but requires precision: Tiny mistakes, like == 1 versus != 0, can break logic.
Write for efficiency in firmware: Avoid unnecessary branching or comparisons.
Think in bits, not just integers: Embedded systems often deal with registers and flags where each bit matters.

#2 Toggling Bits in C

Hrishikesh Karande — Sun, 14 Sep 2025 12:56:27 +0000

When I started learning firmware development, I quickly realized how important bit manipulation is. Whether it’s configuring registers in a microcontroller, controlling hardware pins, or managing flags, bits are everywhere. Recently, I solved a simple but eye-opening problem on EWskill: toggle the 5th bit of a given integer.

This problem not only helped me practice C programming but also gave me insights into how firmware engineers think when working close to the hardware. Let me walk you through what I learned.

Understanding the Problem

The task was straightforward:

Take an integer Nas input.
Toggle (flip) the 5th bit (0-based index) of N.
Print the result.

For example:

Input: 10 (binary: 00001010) → After toggling the 5th bit → 00101010 → Output: 42.
Input: 0 (binary: 00000000) → After toggling the 5th bit → 00100000 → Output: 32.

My Code

Here’s the C program I wrote:

#include <stdio.h>

int toggleFifthBit(int n) {
    n ^= (1 << 5);   // XOR with 1 shifted left by 5
    return n;
}

int main() {
    int n;
    scanf("%d", &n); // Read integer input
    printf("%d", toggleFifthBit(n));
    return 0;
}

Walking Through the Code

1. Including the Standard I/O Library

#include <stdio.h>

This gives us access to functions like scanf (for input) and printf (for output). In embedded systems, you may not always have these functions, but for practice on a PC, they’re perfect.

2. Bit Manipulation with XOR

n ^= (1 << 5);

This is the heart of the program. Let’s break it down:

(1 << 5) means take the binary 1 and shift it left by 5 positions. That gives 00100000 in binary (which is decimal 32).
^= is the XOR assignment operator. It flips the bit at the position where the mask has 1.

If the 5th bit was 0, it becomes 1.
If the 5th bit was 1, it becomes 0.

This single line of code shows how powerful bitwise operations are in C.

3. Input and Output

scanf("%d", &n);
printf("%d", toggleFifthBit(n));

Here, %d tells scanf and printf that we are working with integers.

scanf takes input from the user.

&n means “store the input at the memory address of n.” This was a new concept for me — in C, when we pass variables to functions like scanf, we often need to give their address so the function can modify them.

printf displays the final result.

My Learnings

Bitwise operations are essential in firmware – Toggling bits is a common task when dealing with hardware registers. I now understand how to flip a single bit without disturbing the others.
The power of XOR (^) – I learned that XOR is the perfect tool for toggling.
- OR (|) sets a bit.
- AND (&) clears a bit
- XOR (^) flips a bit.

Knowing when to use which operator is critical for writing efficient firmware.

Shifting (<<) is like positioning switches – Using (1 << position) creates a bitmask. This helps in targeting a specific bit in an integer.
C syntax and operators start making sense – I had always seen operators like ^, &, and | but never fully understood their purpose. This exercise gave me a practical use case.
Thinking like a firmware engineer – Even though this was a simple problem, it trained me to think in terms of binary, registers, and masks, which is exactly how embedded systems work.

Conclusion

This exercise taught me that even a small C program can unlock big lessons in firmware development. Now, when I see a microcontroller register with 32 bits, I know how to target and manipulate a single bit efficiently.

For beginners in C and embedded systems, I’d say: learn bit manipulation early. It’s one of the most valuable skills you’ll carry forward into real hardware projects.

#1 Setting or Clearing a Bit in C

Hrishikesh Karande — Sun, 14 Sep 2025 12:04:55 +0000

When I first got the problem statement on EWskills — “set or clear a specific bit in an 8-bit register using C” — I thought it would be a straightforward coding exercise. But as I worked through it, I realized I was uncovering some important concepts that are directly related to firmware development and low-level C programming.

#include <stdio.h>

unsigned char modifyBit(unsigned char reg, int pos, int mode) {
    // Write your code here
    if (mode == 1) {
        //Set the bit for the position pos
        reg |= (1 << pos);
    } else if (mode == 0)  {
        //Clear the bit at the position pose
        reg &= ~(1 << pos);
    }
    return reg;

}

int main() {
    unsigned char reg; // This is your 8-bit register
    int pos, mode;
    scanf("%hhu %d %d", &reg, &pos, &mode);
    printf("%d", modifyBit(reg, pos, mode));
    return 0;
}

Here are the key things I learned:

1. Registers Are Just Variables in Memory

In firmware development, hardware registers (like GPIO control registers, ADC data registers, etc.) are essentially memory locations that hold specific values. To experiment, I treated an 8-bit register as a normal C variable:

unsigned char reg;

This taught me that C lets us model hardware registers using basic types, but how we choose the type matters a lot.

2. The Role of `char` in C

At first, I was confused — if I declare unsigned char reg;, am I saying reg is a “character”?

The answer is: no, not really.

In C, char, signed char, and unsigned char are all integer types. The keyword “char” simply reflects the size: 1 byte (typically 8 bits).

If I print a char with %c, it looks like a character (based on its ASCII value).
If I print it with %d or %u, it shows the integer value it’s holding.

This clarified why embedded programmers often use unsigned char (or, even better, uint8_t) to represent hardware registers: it’s exactly 8 bits and works perfectly for bitwise operations.

3. Using for Portability

One major learning was that relying on char could lead to portability issues, since the C standard only guarantees that char is at least 8 bits.

For portable and explicit code, I should use:

#include <stdint.h>
uint8_t reg;

This way, I am 100% sure that the “register” I’m working with is exactly 8 bits, no matter the platform or compiler.

I also discovered that for input/output with uint8_t, I need macros like SCNu8 and PRIu8 from <inttypes.h> instead of %hhu.

4. Bitwise Operations Are the Heart of Firmware

To modify bits, I used:

reg |= (1 << pos); → set a bit
reg &= ~(1 << pos); → clear a bit

These tiny one-liners are the building blocks of firmware programming. In real hardware, they let us do things like:

Turn an LED on or off.
Enable/disable an interrupt.
Configure control bits in a peripheral register.

This exercise made me appreciate how bitwise operations are not just theory — they’re the language of hardware control.

5. Format Specifiers and `%hhu`

Another thing I learned is how format specifiers in C work. %u is for unsigned int, but since my variable was an unsigned char, I needed %hhu. The hh modifier tells C to treat the input/output as the smallest integer type.

Later, with uint8_t, I learned that using portable macros like SCNu8 and PRIu8 is safer and more future-proof.

Final Thoughts

This small problem gave me a big set of takeaways:

How C types map to register sizes.
Why <stdint.h> is a must for portable firmware code.
The practical use of bitwise operations in controlling hardware.
The importance of correct format specifiers when dealing with small integer types.

In firmware development, tiny details matter a lot — a single wrong type or operator can make the difference between a working driver and hours of debugging. This exercise reinforced the discipline of writing clear, portable, and hardware-friendly C code.

DEV Community: Hrishikesh Karande

#14 Extracting a Nibble from an 8-bit Register in C

The Problem

Example

My Initial Confusion

1. Decimal vs Hexadecimal vs Binary

2. Writing the Mask

3. A Bug in My First C Code

The Corrected Code

Making It More "Firmware Style"

My Key Learnings

Conclusion

#3 Checking the K-th Bit in C

Understanding the Problem

Writing the Function Step by Step

Making the Function Efficient

Microcontroller-Style Firmware Thinking

My Key Learnings

#2 Toggling Bits in C

Understanding the Problem

My Code

Walking Through the Code

1. Including the Standard I/O Library

2. Bit Manipulation with XOR

3. Input and Output

My Learnings

Conclusion

#1 Setting or Clearing a Bit in C

1. Registers Are Just Variables in Memory

2. The Role of char in C

3. Using for Portability

4. Bitwise Operations Are the Heart of Firmware

5. Format Specifiers and %hhu

Final Thoughts

2. The Role of `char` in C

5. Format Specifiers and `%hhu`