[C] - Passage de mots de n bits en mode de 8 bits

[jorg1n]

Bonjour,

l'intitulé n'est pas très clair, je l'avoue, mais je ne savais pas comment le définir, le mieux c'est que je l'explique rapidement:

voila, j'ai des variables a envoyer en liaison RS485 MODBUS, et pour cela je dois mettre en forme mes variables en mot de 8 bits, et cela pour des variables de type float et short int.

**J'ai réussi a le faire pour la variable short int :
soit:

short int CAPA;
unsigned char CAPALowRegister, CAPAHighRegister;

On a donc:

CAPALowRegister = CAPA;
CAPAHighRegister = CAPA>>8;

**Mais pour une variable de type Float, comment ça se passe, il y a la virgule, le signe,...
J'imagine que j'aurais 4 variables:

unsigned char FloatReg1, FloatReg2, FloatReg3, FloatReg4;

Mais quel "traitement" faut il exercé sur la variable de type Float?

**Sinon, je dois mettre dans un mot de 8 Bits:

unsigned char StateAlarmRegister;

Ces valeurs (tout en sachant que seul le bit 0 (0 ou 1) est intéressant:

unsigned char RELAIS1, RELAIS2, RELAIS3, RELAIS4

et je souhaite avoir donc dans ma variable StateAlarmRegister:
bit0 = bit0 de RELAIS1
bit1 = bit0 de RELAIS2
bit2 = bit0 de RELAIS4
bit3 = bit0 de RELAIS4
bit4 = 0
bit5 = 0
bit6 = 0
bit7 = 0

Comment faire ces deux actions ?

Merci d'avance et bonne soirée a tous
-----

[sdec25]

Salut.
Tu veux découper tes variables en mots, c'est bien ça ?
Le décalage marche bien pour le entiers, mais on peut faire autrement, avec les union :

typedef union {
  short valeur;
  struct {
    char low;
    char high;
  } mots;
} type16

on l'utilise ainsi :

type16 x;
x.valeur = 42; // valeur en short sur 16 bits
x.low; // poids faible de 42
x.high; // poids fort de 42

C'est le même principe pour les float et les int32 :

typedef union {
int32 valeur;
float valFloat;
char mots[4];
} type32

Sans utiliser un nouveau type, on peut aussi caster le type en char :

float x = 1.2;
char firstByte = *((char*)&x);
char secondByte = *((char*)&x+1);
...

[jorg1n]

Merci Sdec25, c'est exactement ça, mais je vais garder ma solution pour les entier, et je vais prendre ta proposition de "castage" pour les float (je ne suis pas encore très à l'aise avec union.. )

Et as tu une proposition pour ma dernière question concernant l'état de mes relais?

Merci encore

[sdec25]

Pour la dernière, on peut faire ça avec une struct et les champs de bits :

typedef struct {
    unsigned int bool0 : 1; // bool0 sur 1 bit
    unsigned int bool1 : 1;
    ...
  }
booleens;

void main() {
  booleens x;
  x.bool0 = 0;
  x.bool1 = 1;
  x.bool2 = 0;
  x.mot; // == 2
}

[A voir en vidéo sur Futura]

[sdec25]

je vais prendre ta proposition de "castage" pour les float (je ne suis pas encore très à l'aise avec union.. )

Pourtant c'est LE cas où les unions sont utiles Sinon on ne le utilise pratiquement jamais.
Si tu ne dois pas souvent découper tes variables, caster les pointeurs ça va bien, mais c'est quand même plus lisible avec les unions.
Je rappelle que dans une union, tous les membres désignent la même variable sous plusieurs noms (et types) différents.

Et j'ai fait une petite erreur :

on peut aussi caster le type en char :

C'est en (char*) qu'on caste le pointeur, parce que caster un int ou un float en char équivaut à tronquer sa valeur sur 8 bits.

Et dans mon post précédent, "x.mot" désigne la variable "mot" d'une union. Sans union, il faut caster.

[jorg1n]

Merci Sdec25,

par contre j'ai une question, peut on déclarer :

typedef struct {
    unsigned int bool0 : 1; // bool0 sur 1 bit
    unsigned int bool1 : 1;
    ...
  }
booleens;

comme structure mais en extern, du genre :

 extern typedef struct {
    unsigned int bool0 : 1; // bool0 sur 1 bit
    unsigned int bool1 : 1;
    ...
  }
booleens;

Car dans mon programme, j'ai plusieurs fichiers .c et j'ai besoin d'utiliser par exemple bool0 un peu partout...

J'espère avoir été clair...

Merci encore

[sdec25]

Car dans mon programme, j'ai plusieurs fichiers .c et j'ai besoin d'utiliser par exemple bool0 un peu partout...

Les types (typedef) ne sont pas considérés comme des variables, il n'y a donc pas besoin de extern.
Il faut les déclarer partout où on les utilise. Le plus simple est de le faire une fois dans un .h, et d'inclure ce .h dans les fichiers .c

Au fait l'utilisation de nombreux cast et des pointeurs est souvent une source d'erreurs, alors fais attention !

[jorg1n]

Il faut les déclarer partout où on les utilise. Le plus simple est de le faire une fois dans un .h, et d'inclure ce .h dans les fichiers .c

donc je déclare ça dans mon fichier toto.h:

typedef struct {
    unsigned int bool0 : 1; // bool0 sur 1 bit
    unsigned int bool1 : 1;
    ...
  }
booleens;

dans mon fichier toto.c, j'écris:

#include toto.h

et ensuite je peu utiliser bool0 comme je veux donc... nikel

Merci encore

[sdec25]

Oui, c'est ça, mais avec toto.h entre guillemets.
A+

[jorg1n]

Excuse moi encore Sdec25,

pour le transfert de l'état de mes relais en un mot de 8 bits, jai pas trop suivi, j'ai donc:

typedef struct {
    unsigned int Relais1 : 1; // Relais1 sur 1 bit
    unsigned int Relais2 : 1;
    unsigned int Relais3 : 1;
    unsigned int Relais4 : 1;
  }
StateRelais;

unsigned char StateRelaisRegister;

Je ne vois pas trop, tu m'as dis de faire soit avec une union, soit avec un cast, peux tu me détailler le cast s'il te plait?

Merci encore

PS:dsl pour les guillemets... oubli de ma part

[sdec25]

Je ne vois pas trop, tu m'as dis de faire soit avec une union, soit avec un cast, peux tu me détailler le cast s'il te plait?

On a 2 types :

• un mot (entier de 1 octet)
• une structure de 4 * 1 bit

L'idée c'est de copier le contenu de la structure dans le mot. La première solution est de placer ces 2 types dans une union :

typedef union {
  StateRelais etat;
  char mot;
}
unionStateRelais;

etat et mot désignent la même variable avec 2 types différents. On peut passer de l'un à l'autre sans problème.

La 2ème solution est de copier la zone mémoire de 1 octet correspondant à StateRelais :

StateRelais etat;
char x;
etat.Relais1 = 1;
...
x = (char)etat; // pas sûr que le compilateur accepte
// ou bien :
x = *((char*)&StateRelais); // marche à coup sûr

Pour bien comprendre cette dernière ligne il faut connaître les pointeurs.

[jorg1n]

Merci Beaucoup Sdec25,

je testerai ça plus tard...
Bonne soirée a toi...

[sdec25]

Il y a une erreur de frappe dans mon dernier post :

x = *((char*)&StateRelais); // marche à coup sûr

C'est etat et pas StateRelais...

je testerai ça plus tard...

ok, tiens nous au courant

Bonne soirée

[jorg1n]

Bonjour à tous...

bon j'ai testé ce que tu m'a dis, voila ce que j'ai fais:

déclaration:

unsigned char StateRelaisRegister;

typedef struct {
    unsigned RELAIS1_bit:1; // Relais1 sur 1 bit
    unsigned RELAIS2_bit:1;
    unsigned RELAIS3_bit:1;
    unsigned RELAIS4_bit:1;
  }StateRelais;
StateRelais State;

Utilisation:

State.RELAIS1_bit = 1;
State.RELAIS2_bit = 1;;
State.RELAIS3_bit = 1;
State.RELAIS4_bit = 1;
StateRelaisRegister = *((char*)&State);

Et ça marche parfaitement...

Bon et si je veux utiliser mes bits RELAIS1_bit... dans plusieurs ".c", et bien je met ma déclaration:
[/CODE]typedef struct {
unsigned RELAIS1_bit:1; // Relais1 sur 1 bit
unsigned RELAIS2_bit:1;
unsigned RELAIS3_bit:1;
unsigned RELAIS4_bit:1;
}StateRelais;
StateRelais State;[/CODE]

dans un fichier toto.h et dans chaque ".c" où je souhaite utiliser un de mes bits, je met en entête :

#include <toto.h>

Par contre, je met aussi le:

StateRelais State;

dans le toto.h ?

Merci encore pour ton aide et bonne journée a tous

[sdec25]

Salut.

Par contre, je met aussi le:

StateRelais State;

dans le toto.h ?

Non, les variables globales sont à déclarer une seule fois. Si tu la mets dans un .h elle va être déclarée plusieurs fois et tu auras une erreur à l'édition de liens.
Si tu veux l'utiliser dans plusieurs fichiers, mets la dans un .c et en extern dans les autres .c où tu veux l'utiliser.
A+

[jorg1n]

Donc si je récapitule,

je met dans TOTO.h:

typedef struct {
    unsigned CDE_GE_bit0:1; // Relais1 sur 1 bit
    unsigned WARNING_bit1:1;
    unsigned ALARM_bit2:1;
    unsigned DEFAULT_bit3:1;
  }StateRelais;

dans TOTO1.c:

#include <toto.h>

StateRelais State;

et dans TOTO2.c:

#include <toto.h>
extern StateRelais State;

C'est bien ça?

[sdec25]

Oui c'est exactement ça
Et si #include <toto.h> ne fonctionne pas, essaie #include "toto.h"

Sinon, au lieu d'écrire *((char*)&x) à chaque fois, tu peux utiliser la macro suivante :

#define GET_BYTE(x, n) (*((char*)&x + n))

à définir dans le .h et qui s'utilise comme ça :

char mot1 = GET_BYTE(State, 0);
char mot2 = GET_BYTE(State, 1);

[jorg1n]

Merci Beaucoup Sdec25 pour ton aide...

Je te souhaite une bonne journée et à bientot