Comment convertir Char en Hex stocké sous forme uint8_t?

Question

Supposons que j'ai ces variables,

const uint8_t ndef_default_msg[33] = {
    0xd1, 0x02, 0x1c, 0x53, 0x70, 0x91, 0x01, 0x09,
    0x54, 0x02, 0x65, 0x6e, 0x4c, 0x69, 0x62, 0x6e,
    0x66, 0x63, 0x51, 0x01, 0x0b, 0x55, 0x03, 0x6c,
    0x69, 0x62, 0x6e, 0x66, 0x63, 0x2e, 0x6f, 0x72,
    0x67
};
uint8_t *ndef_msg;
char *ndef_input = NULL;

Comment puis-je convertir ndef_input (qui est juste un texte brut, comme "bonjour") à Hex et à sauver dans ndef_msg? Comme tu peux le voir ndef_default_msg est sous forme hexagonale. Données à l'intérieur ndef_msg devrait être quelque chose comme ça aussi.

Un peu d'arrière-plan, dans le programme original (code source), le programme ouvrira un fichier, obtiendra les données et les mettra à l'intérieur ndef_msg, qui sera ensuite écrit dans une carte. Mais je ne comprends pas comment cela peut prendre les données et se convertir en hexadécimal.

Je souhaite simplifier le programme afin qu'il demande directement à l'utilisateur du texte (au lieu de demander un fichier).

Answer 1

Pourquoi ne pas le lire directement dans NDEF_MSG (moins le 0 s'il supposait être un tableau pur). Les Hex sont juste pour la présentation, vous auriez pu choisir une décimale ou un octal sans conséquence pour le contenu.

void print_hex(uint8_t *s, size_t len) {
    for(int i = 0; i < len; i++) {
        printf("0x%02x, ", s[i]);
    }
    printf("\n");
}

int main()
{
    uint8_t ndef_msg[34] = {0};

    scanf("%33s", ndef_msg);
    print_hex(ndef_msg, strlen((char*)ndef_msg));


    return 0;
}

Vous devez probablement gérer la lecture de la chaîne différemment pour permettre l'espace blanc et peut-être ignorer \0, c'est juste pour illustrer mon point.

Answer 2

Peut-être pas très élégant mais simple: définissez une table de recherche qui mappe un code de caractère (0 à 255) dans une valeur souhaitée.

// something like this:
for( i = 0; i < INPUT_LEN; ++i ) {
    value_in = input[i];
    value_out = lut[value_in];
    array_out[i] = value_out;
}

J'ai utilisé de telles solutions non élégantes à quelques reprises (par exemple pour la cartographie des couleurs) et cela a fonctionné aussi bien que d'autres solutions de fantaisie

Answer 3

Si je comprends bien, vous lisez les données du format hexadécimal stocké dans ndef_input, analyser et enregistrer la valeur dans ndef_msg.

vous pouvez utiliser

// parse the hex string and store it in an int variable
int temp_int;
sscanf(ndef_input, "%x", &temp_int);
// covert it to uint8_t type
ndef_msg = malloc(sizeof(uint8_t));
*ndef_msg = (uint8_t)temp_int;

Answer 4

char *ndef_input="Z";

uint8_t b=90; //assume this is your character Z in decimal ascii code 90 and HEX = 5A
uint8_t LSB = b & 0x0F; // this is LSB 10 decimal = A
uint8_t MSB = (b & 0xF0)>>4; // this is MSB 5 in decimal = 5 in Hex
cout << "MSB" << MSB << "LSB" << LSB;

Answer 5

J'espère que cela peut vous aider

/*
 *  DESCRIPTION
 *    Converts a block in ASCII representation to binary
 *  PARAMETERS
 *    char * inMessage      : message in ASCII format, '\0' terminated
 *  OUTPUTS
 *    uint8 * outMessage    : output message in binary format
 *                    Format: outMessage[i], where i is byte number
 *  RETURN VALUE
 *    uint32                : number of converted bytes
 */
uint32 ascii2hex_block( uint8 * outMessage, int32 out_len, const char * inMessage )
{
    #define SET_BIT(U,N)   ((U) |=   (0x1 << (N)))

    int32   i = 0;
    int32   k = 0;
    int32   blockLen = 0;
    char    inChar;
    uint8   hexVal;
    uint32  retVal = 0;

    while ( inMessage[blockLen]!='\0' )     blockLen++;
    blockLen = blockLen >> 1;

    if (blockLen <= out_len)                        // not enough space in output
    {
        retVal = blockLen;
        for (i = 0; i < blockLen; i++)
        {
            outMessage[i] = 0;
            inChar = inMessage[k];
            hexVal = ascii2hex( inChar );
            if (hexVal == 0xff) retVal = 0;     // found an invalid character
            if ( (hexVal & (0x1 << 0) ) != 0 )  SET_BIT( outMessage[i], 4 );
            if ( (hexVal & (0x1 << 1) ) != 0 )  SET_BIT( outMessage[i], 5 );
            if ( (hexVal & (0x1 << 2) ) != 0 )  SET_BIT( outMessage[i], 6 );
            if ( (hexVal & (0x1 << 3) ) != 0 )  HELPER_SET_BIT( outMessage[i], 7 );
            k++;
            inChar = inMessage[k];
            hexVal = ascii2hex( inChar );
            if ( (hexVal & (0x1 << 0) ) != 0 )  SET_BIT( outMessage[i], 0 );
            if ( (hexVal & (0x1 << 1) ) != 0 )  SET_BIT( outMessage[i], 1 );
            if ( (hexVal & (0x1 << 2) ) != 0 )  SET_BIT( outMessage[i], 2 );
            if ( (hexVal & (0x1 << 3) ) != 0 )  SET_BIT( outMessage[i], 3 );
            k++;
        }
    }   

    return retVal;
}

Et ascii2hex est défini comme suit:

/*
 *  DESCRIPTION
 *    Converts an ascii character ('0'..'f' or '0'..'F') to corresponding integer value.
 *    In case of invalid ascii character, return value is 0xff
 *  USAGE
 *    uint8 ascii2hex( char inASCII );
 *  PARAMETERS
 *    char inASCII  : ascii character to convert
 *  RETURN VALUE
 *    uint8         : value of inASCII, 0xff for invalid input
 */
uint8 ascii2hex( char inASCII )
{
    uint8 retHex=0xff;

    if( (inASCII>=48) && (inASCII<=57) )
        retHex = inASCII-48;
    else if( (inASCII>=65) && (inASCII<=70) )
        retHex = inASCII-55;
    else if( (inASCII>=97) && (inASCII<=102) )
        retHex = inASCII-87;

    return retHex;
}