Bonjour,
Un mot sur les valeurs transmises
Le codage d'un octet (byte) en mémoire est très simple.
C'est une valeur comprise entre 0 et 255 (ou 0 et FF).
En C, son interprétation dépend de la déclaration.
Si c'est un "char", la valeur est dite signée et son domaine va
de -128 à 127 (donc 255 cas possibles, le 0 est compté comme nombre positif)
Si c'est un "unsigned char", la valeur est dite non signée et son domaine
va de 0 à 255.
Le codage d'une valeur autre que "char" se fait sur plusieurs octets:
short int sur 2 octets
int sur 4 octets
long sur 4 octets
float sur 4 octets
double sur 8 octets
et il existe aussi
long long sur 8 octets
long double sur 12 octets
La question est de savoir comment la valeur est stockée.
En pratique, ce n'est pas trivial et il y a des normes pour cela.
Un flottant comportera un octet pour le signe, un octet pour l'exposant et deux octets pour la mantisse.
Bref, toute une tambouille qui fait que la lecture des 4 octets d'un float ne s'interprète pas de
manière simple.
prog_PC et dummy_12AX7 sont tous les deux prévus pour échanger des flottants donc, à priori, on
ne s'occupe pas du transcodage, c'est transparent. Maintenant, si l'on veut connaitre les
4 octets transmis, il faut aller lire directement en mémoire la valeur des 4 octets.
[Désolé, ce chapitre va être un peu technique.]
Quand je déclare p comme pointeur, sa valeur n'est pas la valeur de la variable
mais l'adresse mémoire à laquelle est stockée la variable.
Il faut savoir que le C dispose d'une arithmétique des pointeurs.
Si je déclare p un pointeur de char et que je fais p=p+1, le pointeur se
décale en mémoire de 1 octet. Pour l'instant cela semble logique.
Mais si je déclare p comme pointeur de float et que je fais p=p+1, alors
le pointeur se décale en mémoire de 4 octets. En effet 4 = taille d'un float en mémoire.
Donc, si je veux lire la valeur des 4 octets d'un float, il me faut un pointeur
qui pointe sur le premier des 4 octets et que je peux déplacer octet par octet.
Ainsi:
addr est un pointeur déclaré pour adresser un octet. Pour l'instant addr ne pointe sur rien.
--> unsigned char *addr;
Là, c'est le tour de passe passe. Je suis tenté d'affecter à addr l'adresse de la variable v
addr=&v; Mais comme v est un flottant et addr un pointeur d'unsigned char, le compilo
dit que cela n'est pas cohérent (c'est normal) et il refuse de compiler. Donc je ruse et je force
l'affectation de l'adresse du flottant en imposant que cela soit une adresse d'unsigned char.
--> addr=(unsigned char*)&v;
Arrivé là, je me retrouve avec addr qui pointe sur le premier des 4 octets du flottant
et il suffit donc de l'incrémenter (au sens arithmétique pointeur) pour explorer les
3 autres octets du flottant.
--> printf("%x %x %x %x\n",cmde,*addr,*(addr+1),*(addr+2),*(addr+3));
Et voilà, l'affaire est dans le sac [fin du chapitre pénible]
Après le diner, je dirai un mot sur Cutecom.....
PS: C'est marrant, les fins de ligne de code sont parfois interprétées comme des smileys..
