binary sequence in uint8_t

Question

I'm trying to create a table in "c" (for an embedded application) where each row is a sequence of 8 bits, for example:

11010011
01010011
10000000

then I need to have functions to set/clear/read any bit in any row. What is the most efficient way to do that?

For bit manipulation I thought to use:

uint8_t msk = 0x01;
row3 |= msk;

But to do this I think I need to define row3 (and every row) as uint8_t and convert it to hexadecimal as well, and that leads me to my second question:

how to store an 8-bit binary sequence in a uint8_t? I've seen different ways to do similar tasks like the one discussed here but none of them worked for me. Can you help me? Thanks.

Answer 1

To represent binary bit patterns in C, it is normal to use hexadecimal notation. The utility of hex is that a single hex digit exactly coincides with 4 binary digits, so with experience you can quickly convert between the 16 hex digits and the corresponding binary value in your head, and for longer integers it is simply a matter of converting each digit in turn - 4 bits at a time. Representing long integers in binary quickly becomes impractical.

So your table might be represented as:

uint8_t row[] = { 0xd3, // 11010011
                  0x53, // 01010011
                  0x80  // 10000000
                } ;

Then you set/clear bits in the following manner:

row[2] |= mask ;  // Set mask bits
row[0] &= mask ;  // Clear mask bits

To create a mask specifying numbered bits without hard-coding the hex value you can use an expression such as:

uint8_t mask = 1<<7 | 1<<5 | 1<<0 ;  // 10100001 mask bits 0, 5 & 7

Occasionally a "visual" binary representation is desirable - for character bitmaps for example, the character A is much easier to visualise when represented in binary:

00000000  
00011000  
00100100  
01000010  
01111110  
01000010  
01000010  
00000000  

It is possible to efficiently code such a table while maintaining the "visualisation" by exhaustively defining a macro for each binary value; e.g:

#define B_00000000 0x00 
#define B_00000001 0x01 
#define B_00000010 0x02 
#define B_00000011 0x03 
#define B_00000100 0x04 
...
#define B_11111110 0xfe 
#define B_11111111 0xff

Note to create the above macros, it is best perhaps to write a code generator - i.e. a program to generate the code, and put the macros in a header file.

Given such macros you can then represent your table as:

uint8_t row[] = { B_11010011
                  B_01010011
                  B_10000000
                } ;

or the character bitmap for A thus:

uint8_t charA[] = { B_00000000,  
                    B_00011000,  
                    B_00100100,  
                    B_01000010,  
                    B_01111110,  
                    B_01000010,  
                    B_01000010,  
                    B_00000000 } ;

In the case that the bits are received at run-time serially, then the corresponding uint8_t can be built using sequential mask and shift:

uint8_t getByte()
{
    uint8_t mask = 0x80 ;
    uint8_y byte = 0 ;

    while( mask != 0 )
    {
        uint8_t bit = getBit() ;
        byte |= bit ? mask : 0 ;
        mask >>= 1 ;
    }

    return byte ;
}

What the getBit() function does is for you to define; it may read a file, or a string, or keyboard entry for example, but it must return either zero or non-zero or the binary digits 0 and 1 respectively. If the data is received LSB first then the mask starts from 0x01, and a << shift used instead.

Answer 2

C doesn't have a syntax for entering binary literals, so you should type them as octal or hex, e.g.

uint8_t row1 = 0xd3;
uint8_t row2 = 0x53;
uint8_t row3 = 0x80;

See How do you set, clear, and toggle a single bit? for how you can manipulate specific bits.

row3 |= mask;

will set the bits that are set in mask.

Answer 3

If I understand correctly, you require a list of hexadecimal numbers and you would like to manipulate the bits in any of the elements of the list. I would approach it by making an array of unsigned integers with the size of the array being defined by the number of elements you need in your table.

    #include <stdio.h>
    #include <stdint.h>
    #define LIST_SIZE 3

    //accepts the array and sets bit_pos bit of the list idx
    int set_bit(uint8_t* hex_list, int list_idx, int bit_pos){
        hex_list[list_idx] = hex_list[list_idx] | 0x01<<bit_pos; //left shift by the bit position you want to set
    }

    int clear_bit(uint8_t* hex_list, int list_idx, int bit_pos){
        hex_list[list_idx] = hex_list[list_idx] & ~(0x01<<bit_pos); //left shifts and does logical inversion to get the bit to clear
    }

    int main(void) {
        uint8_t hex_list[LIST_SIZE] = {0x00, 0x01, 0x02};
        set_bit(hex_list, 0, 1); // will make 0th element 0x00-> 0x02 by seting bit position 1
        clear_bit(hex_list, 1,0); //will make 1st element 0x01-> 0x00 by clearing bit position 0

        set_bit(hex_list, 2, 0); // will make 2nd element 0x02->0x03 by setting bit at position 1
        clear_bit(hex_list, 2 , 0);// will make 2nd element 0x03 ->0x02 by clearing bit at position 0

        //print the result and verify
        for(int i = 0; i<LIST_SIZE; ++i){
            // modified array will be {0x02, 0x00, 0x02}
            printf("elem%d = %x \n", i, hex_list[i]); 
        }
        return 0;
    }

An uint8_t in represents a 8-bit unsigned integer whose value can vary between 0(binary representation = 00000000)to 255(binary representation = 11111111).