Discussion :

[vergezzois]

Bonjour à toutes à tous
voilà je vous expose mon soucis:

Je dois réaliser en projet pour les vacances pour l'IUT un programme pouvant calculer le CRC d'une trame de réseau CAN.

Là ou je bloque c'est au moment de réaliser le fameux donc décallage à droite.
je vous pose la formule mathématique:
voici pour la boucle initial.

RESTE[0 à 15]=TRAME[0 à 15] XOR GENERATEUR[0 à 15];
RESTE[16]=TRAME[16]

pour la suite et fin nous avons.

RESTE[0 à 15]=RESTE[1 à 16] XOR GENERATEUR[0 à 15]
RESTE[16]=TRAME[16+c]

c'est donc à partir de là que ce pose le problème, comment transposer la deuxième partie en code?

j'avais pensé à

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
for(d=0;d<15;d++)
    {
<div style="margin-left:40px">RESTE[d]=TCAN[d]^GENERATEUR[d];</div>//XOR entre la trame et le générateur pour le premier cas (premières valeurs de RESTE)
    }
    RESTE[16]=TCAN[16];
 
for(c=0;c<(longueur-17);c++)
{
    <div style="margin-left:40px">for(d=0;d<(longueur-17);d++)
         {
         RESTE[d]=RESTE[d+1]+GENERATEUR[d];
         }</div>
RESTE[16]=TRAME[17+c];
}

pourriez vous valider SVP =). Si besoin je peu vous poster tout le prgm

[Steph_ng8]

Bonsoir.
Pas sûr de comprendre ce que tu veux...

Un bout de code serait bienvenu...

Au fait, utilise les balises [CODE] (bouton « # ») pour poster du code.

[vergezzois]

Oups désolé pour le

Code :

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

 code

Bon alors voilà la source du problème, j'ai essayé d'expliquer le mieux possible =/.

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
/////////////////////////////////////////////////////////////////////////
//CAS 1.0 si nous avons une trame standard
if(TCAN[12]==0)
{
/////////////////////////////////////////////////////////////////////////
//CAS 1.1 si nous avons une trame de requette standard
    if(TCAN[11]==1)
    {
        STANDARD_REQUETE(TCAN[longueur], GENERATEUR[16]);
    }
/////////////////////////////////////////////////////////////////////////
//CAS 1.2 si nous avons une trame de donnée standard
    else
    {
        STANDARD_DONNEE(TCAN[longueur], GENERATEUR[16]);
    }
}
 
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
//CAS 2.0 si nous avons une trame étendue
 
else if(TCAN[12]==1)
{
/////////////////////////////////////////////////////////////////////////
//CAS 2.1 si nous avons une trame de requette étendue
    if(TCAN[31]==1)
    {
        ETENDUE_REQUETE(TCAN[longueur], GENERATEUR[16]);
    }
/////////////////////////////////////////////////////////////////////////
//CAS 2.2 si nous avons une trame de donnée étendue
    else
    {
        ETENDUE_DONNEE(TCAN[longueur], GENERATEUR[16]);
    }
}

Et un sous programme (les 4 sont sensiblement les mêmes seul les bornes changent)

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
void STANDARD_REQUETE(unsigned int TCAN[longueur], unsigned int GENERATEUR[16])
{
    printf("\n \n vous avez donc une trame de requete \n");

    for(d=0;d<15;d++)
    {
        RESTE[d]=TCAN[d]^GENERATEUR[d];
    //XOR entre la trame et le générateur pour le premier cas ( 15 premières valeurs de RESTE)
    }
    RESTE[16]=TCAN[16];//16eme bits de reste viens de la trame

   for(c=0;c<(longueur-17);c++)//-17 car il ne faut pas inclure le CRC présent dans la trame initial
    {
        for(d=0;d<15;d++)
        {
            RESTE[d]=RESTE[d+1]+GENERATEUR[d]; //
        }

    RESTE[16]=TCAN[17+c]; //descente du bit suivant de la trame
    }

    for(x=0;x<16;x++)
    {
        RESULTAT[x]=RESTE[x]^TCAN[18+x];//CRC commence au 19ème bit or tableau commence à 0
    }

    if(RESULTAT==0)
    {
        printf("votre tramme est bonne \n \n");
    }
    else printf("\n \n votre tramme est fausse \n \n");
}

et donc je voulais savoir si ma boucle for en italique permettez bien de faire un RESTE[] XOR GENERATEUR [] pour les 15 premières valeurs de RESTE[] (sachant qu'on décalle à gauche pour libérer la dernière case du tableau) et de remplir la dernière case de RESTE[] avec une valeur d'un troisième tableau TCAN[] qui change d'un pas vers la droite de la trame à chaque fois, sachant que ma première boucle entre TCAN[]^GENERATEUR[] permet d'avoir les 16 premières valeurs de RESTE[] et qu'à la fin du calcul je dois avoir 16 valeurs pour RESTE[]

Source d'erreur possible:
-Pas une bonne écriture pour caractérisé la descente du 16ème bit de RESTE[] venant de TCAN[]
-Pas une borne de départ correcte pour mon for en italique (genre je prend en compte deux fois les premiers bits de TCAN[])
-Moi

Merci de votre aide!

[Steph_ng8]

Sans connaissance sur le domaine, ce code me paraît correct.
Après, pour le décalage :

Code :

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

RESTE[d] = RESTE[d+1] + GENERATEUR[X];

je ne saurais dire si X doit valoir d ou d+1.
Sinon, ce n'est pas l'opérateur ^ qu'il faudrait utiliser à la place de l'opérateur +


À part ça, j'ai relevé quelques erreurs de programmation.
Dans le bloc de code avec les appel des fonctions, tu passes comme paramètres des éléments d'un tableau.
Or, la signature de ces fonctions indiquent qu'elles attendent des tableaux comme paramètres.
À moins que les variables utilisées lors de l'appel soient des tableaux de tableau (ce qui ne semble pas être le cas), ça provoquera une erreur de compilation.
Je pense que l'appel correct devrait être :

Code :

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

STANDARD_REQUETE(TCAN, GENERATEUR);

On ne peut pas déclarer une variable de type tableau dont la taille est la valeur d'une autre variable.
Il faut impérativement que ce soit une constante (nommée ou anonyme).
Alors à moins que longueur soit une constante globale, la déclaration de tes fonctions devrait provoquer une erreur de compilation.

Code ligne 27 :

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

if(RESULTAT==0)

ne devrait pas faire ce que tu attends.
RESULTAT est un tableau, et ne peut être comparé à un nombre.
Mais en C, un tableau est également un pointeur, qui est plus ou moins un entier.
Donc la comparaison ne provoquera pas d'erreur de compilation, mais elle sera entre la valeur du pointeur représentant le tableau (à savoir l'adresse du premier élément) et le pointeur dont la valeur est l'adresse 0x0 (à savoir NULL).
Autrement dit, cette comparaison sera toujours fausse...

Si tu veux vérifier que la « valeur » de ton tableau est nulle, tu passer par une fonction annexe.
Par exemple :

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
int zero(unsigned int tab[])
{
    int i;
    for (i = 0; i < longueur; i++)
        if (tab[i] != 0)
            return 0;
 
    return 1;
}
/* Tu peut utiliser « bool », « true » et « false » si tu inclues l'en-tête « stdbool.h ». */
 
 
/***********************/
 
/* On remplace alors la ligne de tout à l'heure */
if (zero(RESULTAT)) {
    (...)
}

Pour finir, j'ai quelques remarques.

Code :

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

1
2
3
4
5
6
7
8
9
10
#line 12
   for(c=0;c<(longueur-17);c++)//-17 car il ne faut pas inclure le CRC présent dans la trame initial
    {
        for(d=0;d<15;d++)
        {
            RESTE[d]=RESTE[d+1]+GENERATEUR[d]; //
        }
 
    RESTE[16]=TCAN[17+c]; //descente du bit suivant de la trame
    }

Ici, tu peux faire des simplifications en supprimant des opérations atomiques.

Code :

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

1
2
3
4
5
6
for (c = 17; c < longueur; c++)
{
    (...)

    RESTE[16] = TCAN[c];
}

Je peux me tromper, mais j'ai l'impression que les valeurs de tes tableaux ne peuvent être que 0 ou 1.
Si c'est bien le cas, c'est peut-être un peu trop gros d'utiliser des int.
Si à la place tu utilisais des (unsigned) char, tu utiliserais moins d'espace.
Les char peuvent tout à fait s'utiliser comme des entiers ; il y a juste le nombre d'entiers représentables qui est (beaucoup) plus petit.
Mais bon, c'est de la micro-optimisation...

[vergezzois]

Wow ^^'. Merci beaucoup ça c'est de la réponse!

Euh bah je vais reprendre tout ça