If you want to go from the character code to the character itself, you include the character code in the printf format string, escaped with a backslash, in octal.

E.g. printf "\044\n" prints $ (and a newline).

In Bash and other shells, you could use hex, \x24, but that's not standard and doesn't work in Dash.

You could nest another printf in a command substitution to convert from hex or decimal to octal, though. Both of these would print $ (and a newline):

printf "\\$(printf %o 36)\n"
printf "\\$(printf %o 0x24)\n"

In printf in the bash manual, you'll find:

Arguments to non-string format specifiers are treated as C language constants, except that a leading plus or minus sign is allowed, and if the leading character is a single or double quote, the value is the ASCII value of the following character.

(my emphasis)

These shell functions encapsulate char_to_hex and hex_to_char. Function names stolen from perl

# ord: the ascii value of a character
# $ ord "A" #=> 65
#
ord() {
    printf "%d" "\"$1"
}

# chr: the character represented by the given ASCII decimal value
# $ chr 65 #=> A
#
chr() {
    printf "\x$(printf "%x" "$1")"
}

Then:

 printf '%02X\n' "$(ord A)"
41

Oh, sure, just that it has to be done in two steps. Like a two step tango:

$ printf "$(printf  '\\x%s' 48 65 6c 6c 6f)"; echo
Hello

Or, alternatively:

$ test () { printf "$(printf  '\\x%s' "$@")"; echo; }
$ test 48 65 6c 6c 6f
Hello

Or, to avoid printing on "no arguments":

$ test () { [ "$#" -gt 0 ] && printf "$(printf  '\\x%s' "$@")"; echo; }
$ test 48 65 6c 6c 6f
Hello
$ 

That is assuming that the arguments are decimal values between 1 and 127 (empty arguments would be counted but will fail on printing).

Hex:

printf '\x4a'

Dec:

printf "\\$(printf %o 74)"

Alternative for hex :-)

xxd -r <<<'0 4a'

Okay, let's have a shot:

#include <ctype.h>
#include <stdio.h>

static unsigned char hexdigit2int(unsigned char xd)
{
  if (xd <= '9')
    return xd - '0';
  xd = tolower(xd);
  if (xd == 'a')
    return 10;
  if (xd == 'b')
    return 11;
  if (xd == 'c')
    return 12;
  if (xd == 'd')
    return 13;
  if (xd == 'e')
    return 14;
  if (xd == 'f')
    return 15;
  return 0;
}

int main(void)
{
  const char st[] = "48656C6C6F3B", *src = st;
  char text[sizeof st + 1], *dst = text;

  while (*src != '\0')
  {
    const unsigned char high = hexdigit2int(*src++);
    const unsigned char low  = hexdigit2int(*src++);
    *dst++ = (high << 4) | low;
  }
  *dst = '\0';
  printf("Converted '%s', got '%s'\n", st, text);
  return 0;
}

The very verbose-looking digit2int() function is trying to not be ASCII-dependent, which is always nice. Note that the loop in main() assumes proper input, it only checks for termination every two characters and won't handle non-hex data.

Oh, and this prints:

Converted '48656C6C6F3B', got 'Hello;'

you need to take 2 (hex) chars at the same time... then calculate the int value and after that make the char conversion like...

char d = (char)intValue;

do this for every 2chars in the hex string

this works if the string chars are only 0-9A-F:

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

int hex_to_int(char c){
        int first = c / 16 - 3;
        int second = c % 16;
        int result = first*10 + second;
        if(result > 9) result--;
        return result;
}

int hex_to_ascii(char c, char d){
        int high = hex_to_int(c) * 16;
        int low = hex_to_int(d);
        return high+low;
}

int main(){
        const char* st = "48656C6C6F3B";
        int length = strlen(st);
        int i;
        char buf = 0;
        for(i = 0; i < length; i++){
                if(i % 2 != 0){
                        printf("%c", hex_to_ascii(buf, st[i]));
                }else{
                        buf = st[i];
                }
        }
}

The reason is because hexdump by default prints out 16-bit integers, not bytes. If your system has them, hd (or hexdump -C) or xxd will provide less surprising outputs - if not, od -t x1 is a POSIX-standard way to get byte-by-byte hex output. You can use od -t x1c to show both the byte hex values and the corresponding letters.

If you have xxd (which ships with vim), you can use xxd -r to convert back from hex (from the same format xxd produces). If you just have plain hex (just the '4161', which is produced by xxd -p) you can use xxd -r -p to convert back.

you have to use "%X" in the printf():

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

unsigned char global_buffer[5]={0x0A,0x21,0x01,0x01,0x01};

main()
{
   int i;
   for(i=0;i<5;i++) {
       printf("%X, ", global_buffer[i]);
   }
   printf("\n");
}