Insérer un string dans un tableau de type hexa

oui mais ca ne change rien, à partir du moment où tu détermine une valeur héxa et une seule, c'est pareil, tout comme 1 et 8547852 sont deux nombres.
ici on sait que la taille d'un float est 4 octets (8*4 bits donc) et toi tu convertit 8 bit par 8 bit. (si tu regarde l'exemple en rapport avec toi, je fais le traitement sur 8 bit)

Pour info :
1 octet = 8 bit
c'est à dire une valeur comprise entre 0 et 255 (ou -127 et 128).
un float = 8*8 bits soit 64
donc beaucoup plus de valeur possible (je les ai pas en tete). Le but de l exercice est donc de découper par paquet de 8 bits pour générer des caractère, ici 4 (1 par octet).
Au final on aura donc une chaine de 4 caractères représentant un float

et pourquoi je n'arrive pas à compiler le code?

là comme ca je pourrais pas te dire, tu as quoi comme message? quel est ton code?

float f=0.1;
char packetString[10];
sprintf(packetString,"%x\n",*(unsigned int*)&f);
msg[0] = packetString & 0x0F; //ca compile pas

Ton problème ressemble à un problème de sérialisation.

Tu pourrais t'inspirer des solutions mentionnées dans ce fil SO : https://stackoverflow.com/questions/1786137/c-serialization-of-the-floating-point-numbers-floats-doubles

Il y a des bibliothèques qui font cela, tu pourrais regarder leur code. Une bibliothèque (C++) est suggérée par un des contributeurs au fil.

Une des choses à prendre en compte est la endianness, c'est à dire l'ordre dans lequel les octets sont organisés en mémoire, qui n'est pas nécessairement celui que tu penses.

Les processeurs x86 sont basés sur une structure de type "mot de poids faible en tête" (architectures "little-endian") : https://fr.wikipedia.org/wiki/Endianness#Little_endian et l'ordre des octets est renversé par rapport à la lecture "normale".


Dal

Si tu veux te contenter de copier la représentation en mémoire sur ta machine, tu devrais faire comme cela :

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

int main(void)
{
    static char msg[] =
    { 0x2F, 0x76, 0x63, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

    float f = 1.1;
    memmove(msg + 4, &f, sizeof(f));

    return 0;
}

Cela va copier, à partir de msg[4], les octets suivants, dans cet ordre sur une machine little-endian :

0xcd, 0xcc, 0x8c, 0x3f

Dal

Edit : cela est valable sur ma machine avec un processeur 32 bits sous Windows et un code compilé sous gcc ("float" n'est pas spécifié dans le standard du C, on sait juste que c'est de la "single precision" par rapport à "double"). Mais en pratique, sur la plupart des machines cela devrait être effectivement 4 octets actuellement (adhésion à un format proposé par l'IEEE : IEEE 754 single precision floating point).

merci pour l'explication, c'est exactement ce que je veux, sauf que pour avoir 0xcd, 0xcc, 0x8c, 0x3f
je veux 0x3f, 0x8c, 0xcc, 0xcd, sinon il n y a pas d'autre solution valable quelque soit le type du processeur?

Pour les avoir dans l'ordre big-endian sur une machine little-endian, tu copies les octets un par un en partant de la fin.

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

int main(void)
{
    static char msg[] =
    { 0x2F, 0x76, 0x63, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

    float f = 1.1;
    void * f_ptr = &f;
    f_ptr = f_ptr + sizeof(f) - 1;
    char i;
    for (i = 0; i < sizeof(f); i++)
    {
        memmove(msg + 4 + i, f_ptr - i, 1);
    }

     return 0;
}

Cependant, comme indiqué plus haut, ton problème est un problème de "sérialisation" de tes données. Ces données que tu mets dans le tableau, tu vas en faire quelque chose : les stocker, les transmettre, etc. Le récepteur des données doit être capable de "désérialiser", c'est à dire de partir de ton format de représentation de données et de s'en servir pour récupérer la donnée stockée ou transmise.

Il faut qu'aux deux bouts il y ait une même convention sur le format des données sérialisées, et que chacun des bouts s'occupe des particularités liées à sa machine (endianness, notamment).


Dal

Salut Nagashima :-)

OK, vu comme cela, c'est effectivement possible. Je pense que tu veux dire qu'il faut donc appliquer les opérations bit à bit sur l'entier présent en mémoire à l'endroit où est stocké le float. C'est à dire, en passant par une variable pointeur intermédiaire de type entier castée sur l'adresse du float.

Je pense aussi qu'il faudrait rectifier les décalages, car je ne pense pas que ceux que tu proposes tombent juste.

J'aime bien ta solution, elle donne un code C s'occupant de l'endianness.


Dal