Thread: Converting binary array to Byte array

Hi guys,
I have binary array called rxbuffer=[11110001010101010101010101010101010101010101000000 00000000001111111110000000000000011111111110000000 00001111111110000000000000001111111111110000000000 11111111110000000000000000000000000000000000000000 000001]; its size not specifically dividable by 8 , I want to convert this rx buffer to type Byte data, I mean by this every 8bit in my rxbuffer convert them to Byte data, could anyone please help me how do I implement that in C?
my purpose is to get rxbuffer as Byte type array and not binary(0/1) array.

in other words I want to convert my rxbuffer[] from rxbuffer[] that has binary values to this
uint8_t rxBuffer[] , for example the output of what I need looks like this:
uint8_t rxBuffer[] = {5, 1, 2, 3, 4, 5, 0, 0};

thanks alot!

> its size not specifically dividable by 8
So what's your plan for when rxbuffer isn't nicely divisible by 8 ?

Do this 8 times.
byte = (byte << 1) | rxbuffer[i++];

Originally Posted by Brian_Teir

So here byte will be an array that has all the values that I converted? and you mean 8 times , in other worse to do 8 iteration by increasing i 8 times?


for your question if it's not dividable by 8, Im looking for adding zeros from the left till the size of array be dividable by 8, but still not good approach not?

You need to loop in two nested loops. The outer loop represents the byte, the inner loop the bit. The inner loop will be 8 times, the outer loop you can calculate by taking the array size and dividing by eight.

Then you need special logic for the last byte, which might not be a full number of bits. Zero padding is a reasonable strategy, though remember that you'll probably need to store the number of bits somewhere if zero-padding changes the meaning.

The modulus operator is a big help. 8 - (bitsize % 8) will give you the number of padding bits to add, unless bitsize is a multiple of 8 in which case you don't need to add any.

Originally Posted by Malcolm McLean

You need to loop in two nested loops. The outer loop represents the byte, the inner loop the bit. The inner loop will be 8 times, the outer loop you can calculate by taking the array size and dividing by eight.

Then you need special logic for the last byte, which might not be a full number of bits. Zero padding is a reasonable strategy, though remember that you'll probably need to store the number of bits somewhere if zero-padding changes the meaning.

The modulus operator is a big help. 8 - (bitsize % 8) will give you the number of padding bits to add, unless bitsize is a multiple of 8 in which case you don't need to add any.

I've done this code but it doesn't give me the correct result, any help? thanks alot.

unsigned int bitsToBytes(unsigned char *bits)
{
unsigned int sum = 0;
for(int i = 7; i >= 0; i--)
{
sum += bits[i];
sum<<=1;
}
return sum;


}


int main()
{
unsigned char bits[8];
unsigned int byt;
byt = bitsToBytes(bits);
cout << byt; //doesn't give me the right result
}

> //doesn't give me the right result
For starters, your unsigned char bits[8]; contains garbage in the form you've posted it.

At least try to make your example resemble some data in your first post.

Hallo Brian_Teir!

I think it would be better to know from what for a side you want do start to split the whole sentense "rxbuffer" into 8-byte-strings.
In your example you have 4 times with 50 character long tokens and then a token with a length of 6 character.
Including the spaces you have a string of 210 characters length.

First step it would be to separate the 5 tokens form 'rxbuffer' into
4 times 50 characters and 1 time 6 character.

50 divide by 8 ist 6 and divison ramainder two.

So by the 50 characters long tokens you have the problem where you start to separate your 7 decimal values given by characters.
If you want to start at the left side, here is an possible way to do this:

Code:

#include <stdio.h>
#include <string.h> // strcpy, strtok

// argument 2 is an 2-dimensional array where the tokens are copied into
// Return-Value: number of tokens where found
int mixed(char *var, char *delimiter, char numbers[20][60])
{
 
 printf ("the delimiter is: %s(space)\n", delimiter);
 
  int retval = 0, i = 0;
  char * d;
  d = strtok (var, delimiter);
  
  while (d != NULL)
  {
    strcpy(numbers[i], d); 
    //printf ("i: %2d      String: %s\n", i, numbers[i]);
    i++;
    d = strtok (NULL, delimiter);
   retval++;
  }
 
 return retval;
}

// copies byte start to end form string allchars to string result_string
void copychars(char allchars[], char result_string[], int start, int end)
{
 int i, j = 0;

 for (i = start; i <= end; i++)
  {
   result_string[j] = allchars[i];
   result_string[j + 1] = '\0';
   j++; 
  } 
    
}

/* This function bintodec gets the decimal value of an 8 Byte long binary value
 * The first loop is to get length of given string 'wort'
 * ----------------------------------------------------------------------- */
void bintodec(unsigned int (*decval), char wort[])
{
unsigned int i, ende, dumsm, dumza = 0, testvalue = 1;
 
 for (ende = 0; ende <= 8; ende++)
  if (wort[ende] == '\0') break;
  
 testvalue <<= (ende - 1); /* sets testvalue according to length of  string */
 
 for (i = 0; i <= (ende - 1); i++)
  if ((wort[i] == 'I') || (wort[i] == '1'))
   {
    dumsm = testvalue >> i;
    dumza += dumsm;
   } 
 (*decval) = dumza;
}


int main(int argc, char **argv)
{
  int rxlen = -1, i, j, k, start, end; 
  int number_of_tokens = 0;
  
  char delimiter[] = " ";
  char rxbuffer_all[220]="11110001010101010101010101010101010101010101000000 00000000001111111110000000000000011111111110000000 00001111111110000000000000001111111111110000000000 11111111110000000000000000000000000000000000000000 000001"; 
  char parts[6][60] = {0};
  //char bitvalue[12] = {0};
  char bitsofchar[5][6][12] = {0};
  unsigned int decvalues[5][6] = {0};
  
   printf("given was this string:\n%s\n", rxbuffer_all);
   
   rxlen = strlen(rxbuffer_all);
    
   printf("Length of given string is: %d byte\n", rxlen); 
   
   number_of_tokens = mixed(rxbuffer_all, delimiter, parts);
   
   printf ("\nNumber of tokens: %d\n-----tokens splited into characters-------\n", number_of_tokens);
  
   for (i = 0; i < number_of_tokens; i++)
    {
     rxlen = strlen(parts[i]);
     printf("token nr: %2d   Token=%s   length=%d\n", i, parts[i], rxlen);
    }
    
  // Now separate tokens into binary values shown as 8-char-string
  // and put this binay values into int-values  
    
  for (k = 0; k < 5; k++)
   {
    printf("\nToken number %d\n", k);    
   for (i = 0, j = 0; i <= 48; i+= 8, j++)
   {
    start = i;
    end = i + 7;
    copychars(parts[k], bitsofchar[k][j], start, end);
    if (strlen( bitsofchar[k][j]) == 0) break;
    bintodec(&decvalues[k][j], bitsofchar[k][j]);
    printf("j=%2d start=%2d   end=%2d   String=%s   decimal value: %u\n", j, start, end, bitsofchar[k][j], decvalues[k][j]);   
   }  
   
   } 
   
    return 0;
}

first thanks alot for your effort, secondly I want to understand because understanding is more significant for me. lets assume I have rxbuffer with size 18 so 18/8 is 2 and the reminder is two another bits, lets assume my rxbuffer is this:
"111111110000000011" , starting from the left I have first 8 bits as 1...1 at it's first token so to convert it to byte regarding to your code the output must be 255 , the next other 8 bits is 0...0 so to convert it to byte according to your code the output must be zero, now according to your code what about "11" two bits how you're converting them to Byte (I mean by Byte a converting to unit8_t type)? could you explain .. thanks alot!
and the output should be an array like this {1,2,4,5,6} ..every 8bits converted to Byte type(unit8_t type) and output should be an array or list .. like this pattern {1,2,255,0,10,10} , but in your code Im afraid if the output is array or not , for me it's a printing(printf numbers) ..

Appreciate your effort , but you're making it hard for me while you explain about other conversions(like other codes you attached but any way thanks alot for your answer )
So if I understand you unsigned unit8_t is the same as unsigned int yeah? and the array that you store the value of the bytes of the input rxbuffer_all is stored on array called

Code:

unsigned int decvalues

but why the stored array is two denominational array? , in order to output the array that has the bytes values I can just say make the function return decvalues yeah? I tried to update your first attached code but I didn't succeed to write return devalues (to return the array that stores the value bytes-the value that converted them to unit8_t) because the main function must return integer and not an array so Im stuck here

all what I need is to return the array that has the converted values type BYTE - or in other words unit8_t.

Code:

#include <stdio.h>
#include <string.h>

#define byteSize 8

int valueOf(char *bits);
void deBin(char *rx);

int main() {

    deBin( "01110100011001010111001101110100" );

    return 0;
}

int valueOf(char *bits) {
    char retChar = '\0';
    int total = 0, counter = 1;
    for (int i=byteSize; i>0; i--) {
        if (bits[i-1] == '1') total += counter;
        if (bits[i-1] != ' ') counter *= 2;        
    }
    return total;
}

void deBin(char *rx) {
    printf("{ ");
    for (int i=0; i<strlen(rx); i+=byteSize) {
        char nibble[byteSize];
        for (int j=0; j<byteSize; j++) nibble[j] = rx[i+j];

            printf( "%x", valueOf(nibble) );

        if (i+byteSize != strlen(rx) ) printf(", ");
    }
    printf(" }");
}

Originally Posted by Brian_Teir

Appreciate your effort , but you're making it hard for me while you explain about other conversions

If you want a concise answer then I suggest you start by creating a simple and COMPLETE program demonstrating where you're at on the problem. Because as things stand it's a kind of unclear (to me at least) what you're really trying to accomplish.