Thread: converting a hex value into a string

Originally Posted by droseman

Could anyone give me a tip or example to get me going?

This is going to be difficult because their are no "hexadecimal numbers" in C. If you mean this:

Code:

int num = 0x42;

Which the value of this in decimal is 66, but in any case the number is stored in binary, (1000010).

Without printf (which is quite a weird situation), you will need to do something like:

num/16 = 4
num%16 = 2

To get a value for each column, and if that value is more than 9 assign the appropriate letter.

One simple way to do this is to create an array, fill in that array backwards with your string (that'd be "print" it to the buffer as 24x0), then reverse it. You'll use the same code that MK27 shows to do that math portion.

BTW, to get the your "numbers" for Hex, you'll need an if else statement that will get you (0 >= num <= 9) num + '0' (zero), (num >= 9) num % 10 + 'A'

Originally Posted by droseman

that makes a bit of sense, but why modulo division for the lower nibble?

Well, doesn't that make sense? C division rounds down to whole numbers, which is appropriate here, and then the remainder would be the next order of magnitude down. Anyway, try a few numbers, it does work.

On microcontrollers, functions like printf are not included in the library since they are too resource hungry. Makes a difference when your whole application needs to fit into 16 or 32k...
Could there be a method using bitwise functions?

Neat, I've never done embedded stuff. So you want to optimize this as much as possible processor wise too.

Vis, bitwise, well, if you shift right 4, that is the same as /16. For the less significant column, you want to mask out everything BUT the last four bits:

Code:

#include <stdio.h> 

int main() {
        const unsigned int x = sizeof(int)*8-4;
	unsigned int n = 66, one = n>>4, 
		tmp = n<<x, two = tmp>>x;
	
        printf("%u %u\n", one,two);

	return 0;
}

You only have two columns to deal with, so that's it (I tried this on a few numbers, it works). I suppose this will be less expense than the division and modulus.

No matter what, you are still going to need a small table mechanism to map 10-16 to a-f.

Originally Posted by Kennedy

>> No matter what, you are still going to need a small table mechanism to map 10-16 to a-f.

Nah, just the simple if else above.

Not to whine, but that is what I meant by "small table mechanism".

Originally Posted by Kennedy

Sorry, I think of table as in

Yeah, you're right, I guess "table" does have a specific technical meaning. I kind of meant the "concept" of a table like you would draw on paper kind-of-thing...which looks like an actual table array might be the most efficient way, as you point out.

See this post for a thorough example of converting hex to printable.

dump array into file in "hex format"

thanks to kennedy and mk for your ideas. Both would work for me. In your opinion, which of these approaches is likely to have a smaller code footprint?

I went to put this in a test program, but my printf statements have no results. It seems like I have passed my references correctly, could anyone see what I may have missed?

Code:

#include <stdio.h>
#include <stdlib.h>

void num2hexstr(int, char *);

int main(void)
{
    char buffer[3];
    char* buffer_ptr = &buffer[0];
    int number = 31;
    
    num2hexstr(number, buffer_ptr);
    
    printf("array[0]: \n", buffer[0]);
    printf("array[1]: \n", buffer[1]);
    printf("array[2]: \n", buffer[2]);
    printf("array[3]: \n", buffer[3]);    

    
  system("PAUSE");	
  return 0;
}

  void num2hexstr(int num, char *buf)
{
        char tmp[8]; // assuming a 32-bit int.
        int i, j;

        for (i = 0; i < 8; i++)
        {
            j = num & 0xf;
            
            if (j < 10)
            {
               tmp[i] = '0' + j;              // gives hex number if less than 'A'
            } 
            else 
            {
                j -= 10;
                tmp[i] = 'A' + j;             // gives correct hex letter
            }
            num >>= 4;                        // move to next nibble
        }
        
        buf[0] = '0';
        buf[1] = 'x';
        for (i = 2, j = 7; i < 11; i++, j--)
        {
            buf[i] = tmp[j];
        }
        buf[i] = '\0';
        
}

--dave

Originally Posted by droseman

thanks to kennedy and mk for your ideas. Both would work for me. In your opinion, which of these approaches is likely to have a smaller code footprint?

--dave

It looks to me like the table. You can just take the output of your operation for each column (whether you use division and modulus or bit-shifting) and go:

Code:

char table[] = "0123456789abcdef";
int n = 66, tens = n/16, ones = n%16;
char hex[5]="0x";
hex[2] = table[tens];
hex[3] = table[ones];
hex[4] = '\0';