Discussion :

[Zalectron]

Bonjour à tous,

Je souhaiterai coder ma propre trame pour qu'elle puisse ensuite être envoyé sur n’importe quel support de transmission.

Donc tout d'abord, j'aimerai coder la structure de la trame. Ci joint le datagramme de la trame.

Donc comme vous pouvez le constater j'ai des critère à coder sur 4 bits, 8 bits, 16 bits, 32 bits et les données sont variables.

Comment définir un entier sur 4 bits ? pour n’importe qu'elle machine. (Pck je croit que que un entier est codé sur 32 ou 64 bits).

Ensuite mon but est de déterminer à la main , dans une premier temps,les paramètres puis d'afficher dans la console ma trame en binaire. Et en connaissant la longueur de chaque paramètres, je puisse récupérer mes critères déterminer à la main sous forme binaire.

Merci de votre aide !

[ternel]

L'idée de base est d'utiliser un char[] comme canevas pour ta trame.
Partant de là, les opérateurs bits à bits comme x | 0xFF (pour sélectionner les 8 bits de poids faibles) et x << 8 (pour décaler de 8 bits) devraint t'aider.

Cela dit, cela signifiera avoir un driver réseau, tout en bas du système, capable de reconnaitre ta trame.

En fait, il faudra que tout le "réseau" puisse le détecter comme autre chose que du bruit.

[nnovic]

Mais quel est ton besoin, exactement? Un protocole déjà existant ne peut pas te convenir ???

[Delias]

Bonjour et bienvenu sur dvp!

Quand je travail à ce niveau, j'ai pris l'habitude de travailler avec les types uint8_t, uint16_t, uint32_t, uint64_t, éventuellement sans le u pour les types signés.
Ton entête n'est pas optimale, car non alignée sur du 32 et 64bits. (c'est un uint32_t [2.5], ou uint64_t [1.25])
Edit: Ton timestamps devrait être aligné sur une position de uint32[] ce qui nécessite 16bits de remplissage avant lui.

En utilisant l'attribut packed ou aligned (8) de struct et union, tu peux définir un type multiples qui inclus l'entête en tableaux d'entier (de différente tailles selon les nécessités), et également les différentes variables.
Pour le découpage d'un uint_8 en deux variables de 4 bits (mais stockée chaque une sur 8bits, taille atomique de la plupart des systèmes), il faut utilisé le masquage et le décalage comme l'indique ternel.

Sans garantie d'être exact:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
union TEntete{
	uint8_t entete8bit[10];
	uint16_t entete16bits[5];
	struct {
		uint8_t Version_LenEnTete;
		uint8_t LenTotal;
		uint8_t Capteurs;
		uint8_t Checksum;
		uint8_t IDSource;
		uint8_t IDDestination;
		uint32_t Timestamps;
	} __attribute__ ((packed));
} __attribute__ ((packed));

Delias

[Zalectron]

Merci beaucoup Delias,

Je ne comprend pas : uint8_t entete8bit[10]; uint16_t entete16bits[5]; --> Peux tu m'expliquer ?

Et quel est l’intérêt d'avoir une structure dans l'union ?



Je pensais faire quelques choses comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
typedef struct T_trame{
    unsigned Version              : 4 ; //  4 bits
    unsigned Header_Lenght        : 4 ; //  4 bits  --> Header_lenght * 2 = Nbr d'octet de l'en tête
    unsigned Total_Lenght         : 8 ; //  8 bits  --> 2^(total_lenght) - 1
    unsigned Number_Sensors       : 8 ; //  8 bits
    unsigned Cheksum              : 8 ; //  8 bits
    unsigned ID_S                 : 8 ; //  8 bits -> ID Sources
    unsigned ID_D                 : 8 ; //  8 bits -> ID Destination
    unsigned Timestamp            : 32; //  32 bits
    unsigned Option               : 16; //  16 bits
 
//...
}T_trame;

[Delias]

Merci beaucoup Delias,

Je ne comprend pas : uint8_t entete8bit[10]; uint16_t entete16bits[5]; --> Peux tu m'expliquer ?

Et quel est l’intérêt d'avoir une structure dans l'union ?

Je suppose que les trames vont ensuite être envoyées et reçues par de l'UDP, du CAN, du RS485, etc. Or les composants et les librairies qui gèrent ces communications s'attendent en général à recevoir des tableaux d'entier, ou des chaines de caractères.
L'union permet de superposer les définitions, de ce fait on peut la traiter en utilisant sa structure mais l'envoyer et la recevoir sous la forme d'un tableau d'entier.
donnee.entete8bit[1] == donnee.Header_Lenght.

Attention, sur un système 32bits ou 64bits, et sans option d'alignement (qui peut être locale par l'attribut ou globale) les types seront aligné sur leur taille, donc il est fort probable que tu te retrouves avec 16 bits inutilisés avant le Timestamp. Edit: en fait pas avec la déclaration unsigned var: len;.

Delias

[Zalectron]

D’accord, mais je ne comprend pas donnee.entete8bit[1] == donnee.Header_Lenght avec le bout de code que tu as mis. Dans ce que je comprend donnee.entete8bit[0] == donnee.Version ?

Pourquoi tu mets (je ne comprend pas le 10 et le 5

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
	uint8_t entete8bit[10];
	uint16_t entete16bits[5];

[Zalectron]

L'idée de base est d'utiliser un char[] comme canevas pour ta trame.
Partant de là, les opérateurs bits à bits comme x | 0xFF (pour sélectionner les 8 bits de poids faibles) et x << 8 (pour décaler de 8 bits) devraint t'aider.

Cela dit, cela signifiera avoir un driver réseau, tout en bas du système, capable de reconnaitre ta trame.

En fait, il faudra que tout le "réseau" puisse le détecter comme autre chose que du bruit.

Merci Ternel, je vais me renseigner sur ta solution