Convertir des octets en Int / uint en C

J'ai un unsigned char tableau[248]; rempli avec des octets. Comme 2F AF FF 00 EB AB CD EF .....
Ce Tableau est mon Flux d'Octets qui je stocker mes Données à partir de l'UART (RS232) comme un Tampon.

Maintenant je veux convertir les octets de retour à mon uint16 et int32.

En C#, j'ai utilisé le BitConverter Classe pour ce faire. e.g:

byte[] Array = { 0A, AB, CD, 25 };
int myint1 = BitConverter.ToInt32(bytes, 0);
int myint2 = BitConverter.ToInt32(bytes, 4);
int myint3 = BitConverter.ToInt32(bytes, 8);
int myint4 = BitConverter.ToInt32(bytes, 12);
//...
enter code here
Console.WriteLine("int: {0}", myint1); //output Data...

Est-il une Fonction similaire en C ? (no .net , j'utilise le compilateur KEIL parce que le code est en cours d'exécution sur un microcontrôleur)

En Ce Qui Concerne
Sam

Solutions:
Façon Une)

j'ai d'abord eu à convertir ou à initialiser le tableau comme u_int8_t TABLEAU[248];
Ensuite, j'ai utilisé ce code avec votre aide:

 uint32_t* myint1 = (uint32_t *)&RXBUFF[2]; //test
 uint16_t* myint2 = (uint16_t *)&RXBUFF[6]; //test3

À l'Attention de:
La valeur int "1985" dans l'hex est représenté comme 0x07C1 dans myint2 . l'Octet que j'ai envoyé a été "C1 07" donc le Microcontrôleur est en train de changer l'Ordre des Octets

Je vais tester les autres Méthodes.

WR Sam 🙂

source d'informationauteur Sam

9

Oui, il est. Supposons que votre octets dans:
```
uint8_t bytes[N] = { /* whatever */ };
```
Nous savons que, de 16 bits entier est à seulement deux 8 bits entiers concaténés, c'est à dire l'un est un multiple de 256 ou, alternativement, est décalé de 8:
```
uint16_t sixteen[N/2];

for (i = 0; i < N; i += 2)
    sixteen[i/2] = bytes[i] | (uint16_t)bytes[i+1] << 8;
             //assuming you have read your bytes little-endian
```
De même pour 32 bits:
```
uint32_t thirty_two[N/4];

for (i = 0; i < N; i += 4)
    thirty_two[i/4] = bytes[i] | (uint32_t)bytes[i+1] << 8
        | (uint32_t)bytes[i+2] << 16 | (uint32_t)bytes[i+3] << 24;
             //same assumption
```
Si les octets sont lus big-endian, bien sûr, vous inverser l'ordre:
```
bytes[i+1] | (uint16_t)bytes[i] << 8
```
et
```
bytes[i+3] | (uint32_t)bytes[i+2] << 8
    | (uint32_t)bytes[i+1] << 16 | (uint32_t)bytes[i] << 24
```
Noter qu'il y a une différence entre le endian-ness dans stockées entier et au-boutiste " de l'exécution de l'architecture. Le endian-ness visées dans la présente réponse est de la stockées entier, c'est à dire, le contenu de bytes. Les solutions sont indépendantes l'une de l'endian-ness de l'exécution de l'architecture depuis endian-ness est pris en charge lors du passage de.
16

Il n'y a pas de fonction standard pour le faire pour vous en C. Vous aurez à assembler les octets dans votre 16 et 32 bits entiers vous-même. Soyez prudent à propos de l'endianness!

Ici est un simple little-endian exemple:
```
extern uint8_t *bytes;
uint32_t myInt1 = bytes[0] + (bytes[1] << 8) + (bytes[2] << 16) + (bytes[3] << 24);
```
Pour un big-endian, il est simplement l'ordre inverse:
```
uint32_t myInt1 = (bytes[0] << 24) + (bytes[1] << 16) + (bytes[2] << 8) + bytes[3];
```
Vous pourriez être en mesure de s'en tirer avec:
```
uint32_t myInt1 = *(uint32_t *)bytes;
```
Si vous êtes prudent sur les problèmes d'alignement.

            char letter = 'A';
            size_t filter = letter;
            filter = (filter <<  8 | filter);
            filter = (filter << 16 | filter);
            filter = (filter << 32 | filter);
            printf("filter: %#I64x \n", filter);

résultat: "filtre: 0x4141414141414141"

Dans le cas de little-endian, tu ne peux pas utiliser memcpy?

memcpy((char*)&myint1, aesData.inputData[startindex], length);

Vous devez vous connecter pour publier un commentaire.