Bonjour

J'utilise un Kinetis (qui est Little endian comme tous les kinetis, pour info les S08 sont Big endian)
pour faire du modbus
je reçois dans un tableau la valeur 50000 en unsigned int 32bit soit dans l'ordre 4 octets 0, 0 C3 et 50
si je remplis ma valeur en lisant le tableau ainsi
u32Valeur = *(uint32_t*)&au8tableau[3] ; //valeur à partir du 4eme octet
j'obtiens u32Valeur = 1354956800 soit 50,C3,0,0 ce qui est logique puisque le MODBUS est Big endian.

La question : comment remplir u32Valeur simplement en lisant mon tableau ?
ou alors , comment inverser l'ordre des octets de u32Valeur ?

Le problème est surement classique, il y a donc surement des syntaxes efficaces pour faire ça...

Merci par avance

Je ne sais pas avec quel système tu travaille, mais c'est un problème récurrent en réseau. Du coup posix prévoit http://linux.die.net/man/3/htons qui remettent systématiquement les octets dans le bon sens quel que soit l'endianness du processeur

Sinon, toujours avec posix, il existe ces fonctions

Au pire, tu déplaces un à un les octets dans le tableau.

Bonjour Jacques

Je ne suis pas sous unix mais sous FreeRtos

je cherchais en ANSI C mais je ne pensais pas à Freertos or il semblerait qu'il y ait quelquechose qui ressemble fort à ce que tu me suggères
http://www.freertos.org/FreeRTOS-Plus ... ns_ntohs_htonl_ntohl.html
je regarde

Merci

yess

Grâce au nom de ces fonctions je suis tombé sur des macros de freescale dans le SDK de KDS.

//Swap a 16-bit integer
#define _SWAP16(x) ( \
(((x) & 0x00FF) << 8) | \
(((x) & 0xFF00) >> 8))

//Swap a 32-bit integer
#define _SWAP32(x) ( \
(((x) & 0x000000FFUL) << 24) | \
(((x) & 0x0000FF00UL) << 8) | \
(((x) & 0x00FF0000UL) >> 8) | \
(((x) & 0xFF000000UL) >> 24))

//Swap a 64-bit integer
#define _SWAP64(x) ( \
(((x) & 0x00000000000000FFULL) << 56) | \
(((x) & 0x000000000000FF00ULL) << 40) | \
(((x) & 0x0000000000FF0000ULL) << 24) | \
(((x) & 0x00000000FF000000ULL) << 8) | \
(((x) & 0x000000FF00000000ULL) >> 8) | \
(((x) & 0x0000FF0000000000ULL) >> 24) | \
(((x) & 0x00FF000000000000ULL) >> 40) | \
(((x) & 0xFF00000000000000ULL) >> 56))

Il y a la même chose pour charger directement à la bonne valeur, mais là avec mon pointeur sur un tableau ça ne fonctionne pas.

merci