Bit Field in Embedded C Structure: Definition and Usage

A bit field in an embedded C structure is a way to allocate a specific number of bits for a variable inside the structure instead of using a full byte or more. It helps save memory by packing multiple small data values tightly within a single storage unit.

How It Works

Imagine you have a box that can hold 8 items, but you only need to store small flags that take less space than a full item. A bit field lets you divide that box into smaller compartments, each holding just a few bits instead of a whole byte. In embedded C, a bit field inside a structure specifies exactly how many bits a variable should use.

This is useful because normal variables like int or char use fixed sizes (usually 8, 16, or 32 bits), which can waste memory if you only need a few bits. Bit fields pack these small pieces of data together tightly, like fitting many tiny notes into one envelope instead of sending each note in its own envelope.

Example

This example shows a structure with bit fields to store flags using only 1 bit each, saving memory compared to using full bytes.

c

#include <stdio.h>

struct Status {
    unsigned int power_on : 1;  // 1 bit
    unsigned int error : 1;     // 1 bit
    unsigned int mode : 2;      // 2 bits
};

int main() {
    struct Status device = {1, 0, 3};
    printf("Power On: %u\n", device.power_on);
    printf("Error: %u\n", device.error);
    printf("Mode: %u\n", device.mode);
    printf("Size of struct: %zu bytes\n", sizeof(device));
    return 0;
}

Output

Power On: 1
Error: 0
Mode: 3
Size of struct: 4 bytes

When to Use

Bit fields are ideal when you need to store many small flags or values that do not require a full byte, such as status flags, hardware registers, or configuration bits in embedded systems. They help reduce memory usage and can make your program more efficient.

For example, microcontrollers often have limited memory, so using bit fields to represent on/off switches or small ranges of values saves space. However, bit fields should be used carefully because their exact memory layout can depend on the compiler and hardware.

Key Points

• Bit fields allow specifying the exact number of bits for a variable inside a structure.
• They save memory by packing multiple small values into fewer bytes.
• Commonly used for flags, hardware registers, and compact data storage.
• Memory layout and behavior can vary by compiler and platform.

Key Takeaways

Bit fields let you store small data values using only the bits needed, saving memory.

They are useful for flags and small-range values in embedded systems.

Bit fields are defined inside structures with a colon and bit size after the variable name.

Be aware that bit field layout can differ between compilers and hardware.

Use bit fields to optimize memory but test carefully on your target platform.