Discussion: Coder sa propre trame

  1. #1
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juin 2017
    Messages
    10
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ille et Vilaine (Bretagne)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : juin 2017
    Messages : 10
    Points : 1
    Points
    1

    Par défaut 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. Nom : Trame.PNG
Affichages : 136
Taille : 15,7 Ko

    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 !

  2. #2
    Expert éminent sénior

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    juin 2007
    Messages
    4 948
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : juin 2007
    Messages : 4 948
    Points : 16 429
    Points
    16 429

    Par défaut

    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.
    Mes principes de bases du codeur qui veut pouvoir dormir:
    • Une variable de moins est une source d'erreur en moins.
    • Un pointeur de moins est une montagne d'erreurs en moins.
    • Un copier-coller, ça doit se justifier... Deux, c'est un de trop.
    • jamais signifie "sauf si j'ai passé trois jours à prouver que je peux".
    • La plus sotte des questions est celle qu'on ne pose pas.
    Pour faire des graphes, essayez yEd.
    le ter nel est le titre porté par un de mes personnages de jeu de rôle

  3. #3
    Membre expérimenté

    Homme Profil pro
    Responsable des études
    Inscrit en
    mars 2009
    Messages
    537
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Responsable des études
    Secteur : Industrie

    Informations forums :
    Inscription : mars 2009
    Messages : 537
    Points : 1 532
    Points
    1 532

    Par défaut

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

  4. #4
    Modérateur

    Homme Profil pro
    Ingénieur électricien
    Inscrit en
    septembre 2008
    Messages
    455
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur électricien

    Informations forums :
    Inscription : septembre 2008
    Messages : 455
    Points : 1 301
    Points
    1 301

    Par défaut

    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

  5. #5
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juin 2017
    Messages
    10
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ille et Vilaine (Bretagne)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : juin 2017
    Messages : 10
    Points : 1
    Points
    1

    Par défaut

    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;

  6. #6
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juin 2017
    Messages
    10
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ille et Vilaine (Bretagne)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : juin 2017
    Messages : 10
    Points : 1
    Points
    1

    Par défaut

    Citation Envoyé par ternel Voir le message
    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

  7. #7
    Modérateur

    Homme Profil pro
    Ingénieur électricien
    Inscrit en
    septembre 2008
    Messages
    455
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur électricien

    Informations forums :
    Inscription : septembre 2008
    Messages : 455
    Points : 1 301
    Points
    1 301

    Par défaut

    Citation Envoyé par Zalectron Voir le message
    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

  8. #8
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juin 2017
    Messages
    10
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ille et Vilaine (Bretagne)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : juin 2017
    Messages : 10
    Points : 1
    Points
    1

    Par défaut

    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];

  9. #9
    Modérateur

    Homme Profil pro
    Ingénieur électricien
    Inscrit en
    septembre 2008
    Messages
    455
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur électricien

    Informations forums :
    Inscription : septembre 2008
    Messages : 455
    Points : 1 301
    Points
    1 301

    Par défaut

    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 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 ]

  10. #10
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juin 2017
    Messages
    10
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ille et Vilaine (Bretagne)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : juin 2017
    Messages : 10
    Points : 1
    Points
    1

    Par défaut

    Ok je commence a comprendre

    Donc
    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
    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

  11. #11
    Modérateur

    Homme Profil pro
    Ingénieur électricien
    Inscrit en
    septembre 2008
    Messages
    455
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur électricien

    Informations forums :
    Inscription : septembre 2008
    Messages : 455
    Points : 1 301
    Points
    1 301

    Par défaut

    Bonsoir

    Citation Envoyé par Zalectron Voir le message
    Donc uint8_t entete16bit[12] correspond a un tableau 12 case mémoire de 8 bits ?
    Oui

    Citation Envoyé par Zalectron Voir le message
    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 Voir le message
    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 Voir le message
    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é ), 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

  12. #12
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juin 2017
    Messages
    10
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ille et Vilaine (Bretagne)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : juin 2017
    Messages : 10
    Points : 1
    Points
    1

    Par défaut

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

    Citation Envoyé par Delias Voir le message
    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] ?

  13. #13
    Modérateur

    Homme Profil pro
    Ingénieur électricien
    Inscrit en
    septembre 2008
    Messages
    455
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur électricien

    Informations forums :
    Inscription : septembre 2008
    Messages : 455
    Points : 1 301
    Points
    1 301

    Par défaut

    Ben oui!

    Delias

  14. #14
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juin 2017
    Messages
    10
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ille et Vilaine (Bretagne)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : juin 2017
    Messages : 10
    Points : 1
    Points
    1

    Par défaut

    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

  15. #15
    Modérateur

    Homme Profil pro
    Ingénieur électricien
    Inscrit en
    septembre 2008
    Messages
    455
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur électricien

    Informations forums :
    Inscription : septembre 2008
    Messages : 455
    Points : 1 301
    Points
    1 301

    Par défaut

    Et pourtant pour un checksum simple sur 8bits de TrameEnTete déclarée de type T_trame:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    uint8_t checkSum=0;
    for (int i=0; i<12; i++)
        checksum += TrameEnTete.entete8bit[i];

  16. #16
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juin 2017
    Messages
    10
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ille et Vilaine (Bretagne)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : juin 2017
    Messages : 10
    Points : 1
    Points
    1

    Par défaut

    Citation Envoyé par Delias Voir le message
    Et pourtant pour un checksum simple sur 8bits de TrameEnTete déclarée de type T_trame:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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 ?

  17. #17
    Modérateur

    Homme Profil pro
    Ingénieur électricien
    Inscrit en
    septembre 2008
    Messages
    455
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur électricien

    Informations forums :
    Inscription : septembre 2008
    Messages : 455
    Points : 1 301
    Points
    1 301

    Par défaut

    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

  18. #18
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juin 2017
    Messages
    10
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ille et Vilaine (Bretagne)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : juin 2017
    Messages : 10
    Points : 1
    Points
    1

    Par défaut

    Du coup voici ce que ça donne :

    main.c :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 ?

  19. #19
    Modérateur

    Homme Profil pro
    Ingénieur électricien
    Inscrit en
    septembre 2008
    Messages
    455
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur électricien

    Informations forums :
    Inscription : septembre 2008
    Messages : 455
    Points : 1 301
    Points
    1 301

    Par défaut

    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

  20. #20
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juin 2017
    Messages
    10
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ille et Vilaine (Bretagne)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : juin 2017
    Messages : 10
    Points : 1
    Points
    1

    Par défaut

    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 ?

Discussions similaires

  1. Sniffeur qui n'arrive à renifler que ses propres trames.
    Par AntoineCompagnie dans le forum VB.NET
    Réponses: 2
    Dernier message: 27/06/2016, 09h16
  2. Organiser son projet, coder propre
    Par Romaiiiiiin dans le forum Général Python
    Réponses: 6
    Dernier message: 06/03/2015, 21h51
  3. Réponses: 6
    Dernier message: 19/11/2014, 14h06
  4. Coder son propre serveur Web
    Par kripteks dans le forum C
    Réponses: 4
    Dernier message: 04/10/2014, 23h46
  5. Coder son propre site Web Gratuitement
    Par ToutDroit dans le forum Mon site
    Réponses: 3
    Dernier message: 15/12/2011, 17h21

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo