Coder sa propre trame

Version imprimable

19/06/2017, 13h55
Zalectron

1 pièce(s) jointe(s)

Coder sa propre trame

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. Pièce jointe 286813

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 :) !
19/06/2017, 14h49
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.
19/06/2017, 15h32
nnovic

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

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]) :aie:
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:

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

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:

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;

19/06/2017, 16h18
Zalectron

Citation:

Envoyé par 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.

Merci Ternel, je vais me renseigner sur ta solution
19/06/2017, 16h34
Delias

Citation:

Envoyé par 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 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
19/06/2017, 16h47
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:

1 2 uint8_t entete8bit[10]; uint16_t entete16bits[5];
19/06/2017, 17h00
Delias

Ce sont simplement des tableaux de taille fixe, correpondant à ta première entête sans les options, maintenant ils vaudraient 12 et 6.

Et dans la RAM ils sont superposés avec la structure :arrow:donnee.entete8bit[0] est à la même adresse que le premier byte de la structure qui vaut T_trame.Version << 4 | T_trame.Header_Lenght, le [1] à la même adresse que 2ème byte T_trame.Total_Lenght.

Et je crois bien m'être trompé pour mon attention, il n'y a pas d'alignement automatique avec la déclaration unsigned var: len;.

Delias

PS: l'écriture de code en ligne c'est les balises [C] ou [CODEINLINE], fermée avec [/C ] ou [/CODEINLINE ]
19/06/2017, 18h07
Zalectron

Ok je commence a comprendre :roll:

Donc

Citation:

uint8_t entete16bit[12]

correspond a un tableau 12 case mémoire de 8 bits ?
Comment tu justifies ce que tu as dit je ne comprend pas " maintenant ils vaudraient 12 et 6"?

Mon en-tête a une taille de 10 octets ou 12 octets avec les options. Alors je pourrai juste avoir

Citation:

uint8_t entete8bit[12]

, ceci me donnerai un tableau de 12 cases mémoire de 8 bits (avec les options)?

En ce qui concerne mes 2 informations (Version et Longeur en-tête) qui sont codés chacune sur 4 bits, je doit coder les deux sur le même octets ?

ps: C'est la première fois que je post sur un forum, merci de ton aide c'est gentil :)
19/06/2017, 20h39
Delias

Bonsoir

Citation:

Envoyé par Zalectron

Donc uint8_t entete16bit[12] correspond a un tableau 12 case mémoire de 8 bits ?

Oui

Citation:

Envoyé par Zalectron

Comment tu justifies ce que tu as dit je ne comprend pas " maintenant ils vaudraient 12 et 6"?

Tu ne peux pas recevoir une trame de longueur variable, sans avoir au préalable reçu une trame de longueur fixe qui contient la longueur de la partie variable.
De ce fait, dans ton premier message je comprends que l'entête de longueur fixe fait 5 lignes de 16 bits, soit 10 bytes (uint8_t) ou 5 word (uint16_t)
Dans le message #5, tu as ajouté un word d'option de longueur fixe à ton entête (par rapport à ce que j'avais compris dans le 1er message), ce qui ajout 2 bytes ou 1 word à l'entête, donc l'entête fait dès lors 12 bytes ou 6 word.

Citation:

Envoyé par Zalectron

Mon en-tête a une taille de 10 octets ou 12 octets avec les options. Alors je pourrai juste avoir uint8_t entete8bit[12] , ceci me donnerai un tableau de 12 cases mémoire de 8 bits (avec les options)?

Oui mais tu seras em..r à devoir caster les 4 octets dans le timestamp, et tu auras une écriture de code peu lisible. L'Union superpose les différentes structures dans la mémoire. entete8bit[1] et Total_Lenght sont deux accès à la même donnée, ils ont le même pointeur.

Citation:

Envoyé par Zalectron

En ce qui concerne mes 2 informations (Version et Longeur en-tête) qui sont codés chacune sur 4 bits, je doit coder les deux sur le même octets ?

Avec la déclaration que tu utilises (et que j'avais oublié :calim2:), c'est le compilateur qui fait le travail. Tu décris la structure comme ayant 4 bits pour Version, puis 4 bits pour Header_Lenght, ensuite 8 bits pour Total_Lenght, etc. et avec le tableau entete8bit[0] sont les 8 premiers bits, entete8bit[1] sont les 8 suivants, etc.

Donc entete8bit[0] vaut la concaténation de Version et Header_Lenght. Il faut encore vérifier comment est l’alignement est-ce entete8bit[0] = Version << 4 | Header_Lenght ou entete8bit[0] = Version | Header_Lenght << 4. Sur x86 on est en Little Endian donc c'est sauf erreur la 2ème variante. Un petit programme test est vite fait.

Delias
20/06/2017, 10h07
Zalectron

Merci encore, ca me permet de bien comprendre les structure et les unions :)

Citation:

Envoyé par Delias

Oui mais tu seras em..r à devoir caster les 4 octets dans le timestamp, et tu auras une écriture de code peu lisible. L'Union superpose les différentes structures dans la mémoire. entete8bit[1] et Total_Lenght sont deux accès à la même donnée, ils ont le même pointeur.

Du coup, pour le timestamp se trouvera dans la case mémoire uint16_t entete16bits[3] et l'autre moitier dans uint16_t entete16bits[4] ?
20/06/2017, 12h53
Delias

Ben oui!

Delias
20/06/2017, 16h04
Zalectron

OK parfait, je comprend bien maintenant comment coder ma trame :-) !

A présent mon problème est de coder le checksum pour un union. J'ai fait quelques tests mais ce n'est pas bon :?
20/06/2017, 16h39
Delias
Et pourtant pour un checksum simple sur 8bits de TrameEnTete déclarée de type T_trame:
Code:

1 2 3 uint8_t checkSum=0; for (int i=0; i<12; i++) checksum += TrameEnTete.entete8bit[i];
20/06/2017, 16h52
Zalectron
Citation:
Envoyé par Delias

Et pourtant pour un checksum simple sur 8bits de TrameEnTete déclarée de type T_trame:

Code:

1 2 3 uint8_t checkSum=0; for (int i=0; i<12; i++) checksum += TrameEnTete.entete8bit[i];
On devrait faire un modulo 256 après la somme pour avoir le résultat sur 8 bits non ?
20/06/2017, 18h20
Delias

Oui et non. C'est automatique car checksum de type uint8_t est limité à 0-255 (8bits).
Quand on additionne et que le résultat est supérieur, il y a débordement ce qui revient à faire un modulo 256.

Delias

Du coup voici ce que ça donne :) :

main.c :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
#include <stdio.h>
#include <stdlib.h>
#include "structure.h"
 
 
int i ;
uint16_t checkSum=0;
uint8_t  Version = 2;
uint8_t  LnHeader = 10 ;
uint32_t Timestamp = 1412054007 ;
 
union T_trame trame ;
 
char * bin (unsigned long int i)
{
    static char buffer [1+sizeof (unsigned long int)*8] = { 0 };
    char *p=buffer-1+sizeof (unsigned long int)*8;
    do { *--p = '0' + (i & 1); i >>= 1; } while (i);
    return p;
}
 
uint16_t F_Checksum (uint16_t checkSum)
{
    for ( i=1; i<LnHeader; i++)
        if (i != 3)
            checkSum += trame.entete8bits[i];
        checkSum += Version + LnHeader;
        checkSum %= 0xFF ;
}
 
int main(int argc, char *argv[])
{
    trame.entete8bits[0] = Version | LnHeader << 4 ; // Version + longueur en tête
    trame.entete8bits[1] = 200; //Longueur total
    trame.entete8bits[2] = 80; // Nombre de capteur
    trame.entete8bits[4] = 34; //ID de la source
    trame.entete8bits[5] = 63; // ID du destinataire
    trame.entete16bits[3] = Timestamp & 0xFFFF ;
    trame.entete16bits[4] = Timestamp >> 16 ;
 
    printf("La longueur de l'entete est : %d  octets\n",trame.entete8bits[0] >> 4) ;
    printf("La version est : %d\n",trame.entete8bits[0] & 0x0F ) ;
    printf("Le premier octet a pour valeur: %d, en binaire : %s\n", trame.entete8bits[0], bin(trame.entete8bits[0]));
    printf("Longueur totale : %d octets\n", trame.entete8bits[1]) ;
    printf("Nombre de capteurs %d \n", trame.entete8bits[2]) ;
    printf ("Checksum = %d\n", F_Checksum(checkSum));
    printf("ID de la source %d \n", trame.entete8bits[4]) ;
    printf("ID du destinataire : %d \n", trame.entete8bits[5]) ;
    printf("Premiere partie du timestamp %s \n", bin(trame.entete16bits[3])) ;
    printf("Deuxieme partie du timestamp %s \n", bin(trame.entete16bits[4])) ;
    printf("Timestamp decimal : %d\n", (trame.entete16bits[3] | trame.entete16bits[4] << 16)) ;
    printf("Timestamp binaire : %s", bin((trame.entete16bits[3] | trame.entete16bits[4] << 16))) ;
    return 0 ;
}

Structure.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
/*----------------------------------------------------------------------------*/
/* "frame" |       Version      | Longueur d'en-tête |           Longueur totale              | */
/*         |   Nombre capteurs  |  Nombre repetition |             Checksum                   | */
/*         |               ID Source                 |           ID Destinataire              | */
/*         |                                     Timestamp                                    | */
/*         |                                     Timestamp                                    | */
/*         |                               Option + remplissage                               | */
/*         |                                       Données                                    | */
/*----------------------------------------------------------------------------------------------*/
/* Bits    |           4        |           4        |                   8                    | */
/*----------------------------------------------------------------------------------------------*/
#include <stdint.h>
#include <string.h>
#define structure_h
 
 
union T_trame{                  //L'Union superpose les différentes structures dans la mémoire
	uint8_t entete8bits[12]; //tableau 12 cases mémoire de 8 bit
	uint16_t entete16bits[6]; //tableau 6 cases mémoire de 16 bit
	struct {
		//uint8_t Version_LenEnTete;
		uint8_t Version_LenHeader ;
		uint8_t LenTotal;
		uint8_t NbCapteurs;
		uint8_t Checksum;
		uint8_t IDSource;
		uint8_t IDDestination;
		uint32_t Timestamps;
	} __attribute__ ((packed));  //supprimer les bytes de remplissage (padding) utilisés par défaut par le compilateur//cet attribut précise que la mémoire minimale requise doit être utilisée pour représenter le type
} __attribute__ ((packed));

N'hésitez pas si il y a des remarques à faire je suis preneur ;)
Notamment dans la structure pour déclarer le timestamps, uint32 c'est ok :)?

21/06/2017, 14h04
Delias

Bonjour

Plusieurs points qui ne sont pas correct:
- Pourquoi n’utilises-tu pas la structure de ton message #5. Elle est plus adaptée que celle que j'avais mis. (La syntaxe du message 5#, j'y ai touché une fois il y a 10ans, dans des headers qui n'étaient pas de moi)
- Ta fonction F_Checksum, c'est du n'importe quoi au niveau de sa déclaration. (paramètre et valeur de retour). Le calcul par contre est correct. En liaison avec cela as-tu vraiment besoin de variable globale (c'est ce qui fait que le F_Checksum peut fonctionner si j'ai bien suivit) , alors que des variables locales aux fonctions (y compris la fonction main) est normalement recommandé.
- Pourquoi ne pas utiliser le calcul sur 8bits pour le checksum?
- Tu n'as pas compris l'avantage de l'union. Dans ton exemple, à l'exception du calcul du checksum, tu devrais utilisé les éléments de la structure.

Delias
22/06/2017, 09h55
Zalectron

Au final je préfere utilisé la structure que tu as proposé !

D’accord pour le Checksum je voit .

A la place de mettre trame.entete16bits[3] tu veux dire qu'il est préférable trame.Version_LenHeader ?

Pourquoi tu dis que je n'ai pas compris le principe de l'union ?