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];
                }
        }
}

What am I missing here?

To be honest, the code is so far from plausible, that I am going to ignore that question and the code and just present a solution.

// Convert single Hex digit to integer 0-15
int HexNibbleToInt( char nibble )
{
    return nibble > '9' ? 
           nibble - 'A' + 10 : 
           nibble - '0' ;
}

// Convert string of ASCII hex digit pairs representing 
// character codes to character string.
size_t StrToHex( const char strIn[], char strOut[] )
{
    int i = 0 ;
    for( i = 0; strIn[i * 2] != 0; i++)    
    {
        strOut[i] = HexNibbleToInt( strIn[i * 2] ) << 4 |
                    HexNibbleToInt( strIn[i * 2 + 1] ) ;
    }
    strOut[i] = 0 ;
    
    return i;
}

Note that I have omitted the strLen parameter. If it is a pre-condition that the strIn is a null terminated string with an even number of characters, then then you do not need to calculate the length. Since strlen() has to iterate the string to find the NUL and you have to iterate the string in any case, it serves no purpose. Of course a malformed string that is not capitalised hex digit pairs will have undefined behaviour. That is easy to handle, but if the string has already been validated you might not want to spend CPU cycles doing it twice.

Note also that I have returned the length of the output which saves yet another unnecessary and potentially expensive call to strlen():

size_t output_len = StrToHex( hexbuffer, charbuffer ) ; 
HAL_UART_Transmit( &huart3, charbuffer, output_len, 1000);

Moreover as this appears to be targeted at embedded code, I have avoided "expensive" functions such as sprintf() and strtoul(). If you are using them extensively already in the code, then there is probably little marginal cost in using them, but the initial cost of invoking them once may be rather high.

You need to build a number in base10, considering you have all the digits stored in char*buf like so:

//assumtions: n - number of digits
//            digits are ordered MSD first -> buff[0] contains the most significant digit.
 for(i=0;i<n;i++)
    {
       number += buf[n-i-1]*pow(10,i); //number+=digit*10^i
    }

    printf("%x\n", number);

This is not an answer but an observation - using this since it formats code

static char lookup[] = { '0', '1', '2','3','4','5','6','7','8','9','A','B','C','D','E','F' };
int j = 0;
for (i=0; i<ArraySize; ++i)
{
   loc[j++] = lookup[(Tmp[i] & 0xf0) >> 4];
   loc[j++] = lookup[Tmp[i] & 0xf];
}
loc[j] = 0;

makes the code a lot quicker and simpler.

The statement

temp = (*(input)) >> (4*(i-1));

could be rewritten as

uint8 x = *(input);
temp = x >> (4 * (i - 1));

or

temp = input[0] >> (4 * (i - 1));

And now you can see that you are actually shifting the same value for 0, 4, 8, 12,... bits to the right. And when shifting value to the right, you are padding 0's from the left side, therefore after 2 iterations of the loop, your temp variable is always 0.

The result of E1 >> E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type or if E1 has a signed type and a nonnegative value, the value of the result is the integral part of the quotient of E1 / 2^E2. If E1 has a signed type and a negative value, the resulting value is implementation-defined. - ISO/IEC 9899:TC3, Section 6.5.7: Bitwise shift operators

You need to increment your input pointer. However in your code, you would need to repeat the code twice for every byte - for lower and upper 4 bits of the uint8.

This is how I would do it (replaced macro with inline function as pointed out by Olaf in the comment):

/*! \brief Convert nibble (lower 4 bits) to HEX value to avoid using standard libraries.
 */
static inline __attribute__((always_inline, const)) char
NibbleToHex(uint8_t nibble)  {
    return ((nibble <= 9) ? ('0' + nibble) : ('A' + nibble - 10));
}

static void HexToAscii(const uint8_t *input, char *output, uint8_t size) {
    while (size--) {
        *(output++) = NibbleToHex((*input) >> 4u);
        *(output++) = NibbleToHex((*input) & 0x0Fu);
        input++; /*< Move to the next byte. */
    }
}

uint8_t ReferenceNumber[8] = {0x30, 0x40, 0x60, 0x50, 0x80, 0x60, 0x75, 0x95};
HexToAscii(ReferenceNumber, output, sizeof(ReferenceNumber) / sizeof(ReferenceNumber[0])); 

Note: output must always the double the size of the input data (assuming that the size variable equals the length of the input data).

Here's a simplistic function to convert one character to a hexadecimal string.

char hexDigit(unsigned n)
{
    if (n < 10) {
        return n + '0';
    } else {
        return (n - 10) + 'A';
    }
}

void charToHex(char c, char hex[3])
{
    hex[0] = hexDigit(c / 0x10);
    hex[1] = hexDigit(c % 0x10);
    hex[2] = '\0';
}