Discussion :

[mansour67]

Bonsoir,
j'ai convertis un caractère en une suite 7 bits, je veux envoyer ce dernier avec les sockets.
le probleme c'est que je ne sais pas s'il faut utiliser une matrice generatrice que je vais creer moi même ou utiliser les indices.
j'ai trouver ce code sur le net mais j'ai pas bien compris le raisonement.
pour quoi utilise t-il deux octets. ???
quelle regle à suivre pour completer les deux octets.???
merci

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
 
void cod_hamming(char x,FILE *fichier)
 
{
  int j;
  octet oldoc, oc[2];
  oldoc=char2octet(x);
  for (j=0;j<=1;j++)
  {
          oc[j].bit[0]=oldoc.bit[4*j];
          oc[j].bit[1]=(oldoc.bit[4*j]+oldoc.bit[4*j+1]) % 2;
          oc[j].bit[2]=(oldoc.bit[4*j+1]+oldoc.bit[4*j+2]) % 2;
          oc[j].bit[3]=(oldoc.bit[4*j]+oldoc.bit[4*j+2]+oldoc.bit[4*j+3]) % 2;
          oc[j].bit[4]=(oldoc.bit[4*j+1]+oldoc.bit[4*j+3]) % 2;
          oc[j].bit[5]=oldoc.bit[4*j+2];
          oc[j].bit[6]=oldoc.bit[4*j+3];
          fputc(octet2char(oc[j]),fichier);
  }
}

encore merci

[pseudocode]

Généralement, la plus petite unité utilisée pour le stockage et l'envoi de données est l'octet = 8 bits.

Vu que tu as 7 bits de data a envoyer ca nous laisse les choix:

• envoyer 1 octet (8 bits) = 7 bits de data + 1 bit de controle, ce qui est un peu léger question controle.
  
• envoyer 2 octets (16 bits) = 7 bits de data + 9 bit de controle, ce qui est nettement mieux.

Tu peux donc utiliser un code de Hamming(16,7).

Je te conseille tout de meme de considerer que tu as 8 bits de données (et non pas 7). Ca te permet de découper tes données en 2 paquets de 4 bits, et ainsi d'utiliser le code Hamming(8,4) qui est très robuste:

data 8bits = {a,b,c,d,e,f,g,h}
envoyer octet n°1 = Hamming(8,4)*{a,b,c,d}
envoyer octet n°2 = Hamming(8,4)*{e,f,g,h}

[mansour67]

Merci pour votre reponse.

En suivant votre conseil , j'ai essayé de résoudre mon étape du codage un caractère en Hamming.

1. Convertir le caractère en octet de 8 bits.
2. Decouper l'octet en 2 pour avoir deux informations de 4 bits chacune
3. Utiliser le codage da Hamming(8,4) 8 bits en total, 4 d'information et 4 de control
4. Traiter la premiere partie en inserant les bits de control comme suivant:
5. Calcul des bits de control:
6. C1=(partie1[0] +partie1[1]+partie1[3])%2
7. c2=C1=(partie1[0] +partie1[2]+partie1[3])%2
8. c3=C1=(partie1[1] +partie1[2]+partie1[3])%2
9. c4=la prité des bits de control et les bits d'information
10. Creer un nouvel oct qui correspond au codage suivant
11. C1C2 partie1[0] C3 partie1[1] partie1[2] partie[3] C4
12. Convertir l'octet en char et l'enregistrer dans le fichier ,(Fichier codé)

Le petit problème c'est que des fois j'ai des caractères bizarres dans mon fichier codé. Avec 8 bits on peut allez jusqu'à 256 caractères.

Voici une partie de mon code:

Code C :

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
 
void H_8_4(char x)
 
{
    octet donnee;
    int tmp1[4],tmp2[4];//les bites d'information 
    int i;
 
    //convertir le caractère en octet
    donnee=char2octet(x);
    printf("%c\n",octet2char(donnee));
 
    // couper l'octet en 2 
    for(i=0;i<4;i++)
    {
	tmp1[i]=donnee.bit[i];
	tmp2[i]=donnee.bit[i+4];
    }
    codage(tmp1);
    codage(tmp2);
 
}

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
 
 
void codage(int *info)
 
{
    int par[4];//les bites de control
    octet mot_code;
    FILE* out;
    int i;
 
 
    //c1
    par[0]= info[3];
    par[0] ^= (info[1] ^ info[0]);
 
    //c2
    par[1]=info[3];
    par[1] ^= (info[2] ^ info[0]);
 
    //c3
    par[2]=info[3];
    par[2] ^= (info[1] ^ info[2]);
 
    //c4
    par[3] ^=(par[0] ^ par[1] ^ par[2] ^ par[3]);
    par[3] ^=(info[0] ^ info[1] ^ info[2] ^ info[3]);
 
 
    mot_code.bit[0]=par[0];
    mot_code.bit[1]=par[1];
    mot_code.bit[2]=info[0];
    mot_code.bit[3]=par[2];	
    mot_code.bit[4]=info[1];
    mot_code.bit[5]=info[2];
    mot_code.bit[6]=info[3];
    mot_code.bit[7]=par[3];
 
    //ourir le fichier de sortie
    out=fopen("./sortie.txt","w"); 	
    fputc(mot_code.bit[i],out);
 
 
 
 
 
}

la question est: mon plan est-il bien ou je suis dans le faux ???

Merci

[pseudocode]

la question est: mon plan est-il bien ou je suis dans le faux ?

Le principe général m'a l'air bon.

Le petit probleme c'est que des fois j'ai des caractères bizzar dans mon fichier codé. Avec 8 bits on peut allez jusqu'a 256 caractères.

Oui, c'est sur que le caractère généré n'est pas très lisible du fait des 256 valeurs possibles. Si la lisibilité est importante, tu peux te limiter au code de Hamming(7,4), donc 128 valeurs ce qui te permet de te retrouver dans la plage ASCII.

[mansour67]

Le principe général m'a l'air bon.



Oui, c'est sur que le caractère généré n'est pas très lisible du fait des 256 valeurs possibles. Si la lisibilité est importante, tu peux te limiter au code de Hamming(7,4), donc 128 valeurs ce qui te permet de te retrouver dans la plage ASCII.

C'est bon j'ai utilisé Hamming(7,4): 4 bits d'information et 3 bits de control.

Une question, mon code hamming(7,4) est-il juste?. j'ai suivi la définition des bits de control en fonction des bits d'information::::
w1=bit[0]+bit[1] +bit[3].
w2=bit[0]+bit[2]+bit[3].
w3=bit[1]+bit[2]+bit[3].

le mot final:W1 W2 bit[0] W3 bit[1] bit[2] bit[3] 6 7

voici mon code

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
 
 
//Hamming(7,4)
char hamming(char* info)
 
{
    char par[4];//les bites de control
    octet mot_code={NULL};//initialisation
    int i;
 
 
    //c1
    par[0]= info[3];
    par[0] ^= (info[1] ^ info[0]);
 
    //c2
    par[1]=info[3];
    par[1] ^= (info[2] ^ info[0]);
 
    //c3
    par[2]=info[3];
    par[2] ^= (info[1] ^ info[2]);
 
    mot_code.bit[0]=par[0];
    mot_code.bit[1]=par[1];
    mot_code.bit[2]=info[0];
    mot_code.bit[3]=par[2];	
    mot_code.bit[4]=info[1];
    mot_code.bit[5]=info[2];
    mot_code.bit[6]=info[3];
 
    return octet2char(mot_code);
 
 
}

Faut-il utiliser la matrice generatrice G et matrice de partite pour coder et decoder les information ainsi corriger les erreurs?

Merci

[pseudocode]

Ta definition avec les w1,w2,w3 je ne sais pas ce que ca resprésente.

Mais ton code C me parrait bon.

[mansour67]

Ta definition avec les w1,w2,w3 je ne sais pas ce que ca resprésente.

Mais ton code C me parrait bon.

W1,W2,W3 sont les bits de control.
j'ai vu sur certain doc qu'on peut utiliser la matrice generatrice et la matrice de parite pour coder et decider ainsi que detecter l'erreur.
est-elle une bonne methode , mieux que le calcul des bits de control, car ja trouve un peu difficile pour decoder et detecter l'erreur et la correction
.
merci

[pseudocode]

W1,W2,W3 sont les bits de control.
j'ai vu sur certain doc qu'on peut utiliser la matrice generatrice et la matrice de parite pour coder et decider ainsi que detecter l'erreur.
est-elle une bonne methode , mieux que le calcul des bits de control, car ja trouve un peu difficile pour decoder et detecter l'erreur et la correction
.
merci

C'est plus "simple" de décrire un code correcteur sous forme de matrice, et c'est plus simple à coder (pour peu qu'on sache faire des multiplications vecteur/matrice).

Mais c'est plus compliqué de "comprendre" comment le code fonctionne.

[mansour67]

C'est plus "simple" de décrire un code correcteur sous forme de matrice, et c'est plus simple à coder (pour peu qu'on sache faire des multiplications vecteur/matrice).

Mais c'est plus compliqué de "comprendre" comment le code fonctionne.

Je pense que le mieux c'est de passer par les matrices. c'est mieux pour coder et c'est mieux pour décoder et trouver l'erreur.

on sait que le hamming(7,4): detecte 2 erreurs et corrige une erreur.

comment fait t-il pour détecter ces erreurs?

merci

[pseudocode]

on sait que le hamming(7,4): detecte 2 erreurs et corrige une erreur.

comment fait t-il pour détecter ces erreurs?

Tu multiplies les 7 bits reçus par la matrice de contrôle (parity-check) de hamming(7,4). Cela de donne un résultat "R".

- Si R est égal à zéro, alors il y a eu soit aucune, soit plus de 2 erreurs de transmission.

- Si R est différent de zéro, alors il y a eu 1, 2 ou plus erreurs de transmission. Impossible de savoir si c'est 1 ou 2 ou plus. Dans le cas, ou il n'y a eu qu'une seule erreur de transmission, la valeur de R te dit quel bit parmis les 7 a été mal transmis.

[mansour67]

Tu multiplies les 7 bits reçus par la matrice de contrôle (parity-check) de hamming(7,4). Cela de donne un résultat "R".

- Si R est égal à zéro, alors il y a eu soit aucune, soit plus de 2 erreurs de transmission.

- Si R est différent de zéro, alors il y a eu 1, 2 ou plus erreurs de transmission. Impossible de savoir si c'est 1 ou 2 ou plus. Dans le cas, ou il n'y a eu qu'une seule erreur de transmission, la valeur de R te dit quel bit parmi les 7 a été mal transmis.

Ok, j'ai fait le codage de la donnée à enoyer.
je veux creer une structure TRAME qui va contenir :
le numéro de la trame ,
la taille des données
et les données codées:
j'ai un medium qui perturbe la transmission des données, je veux savoir si même le numéro de la trame et la taille peuvent etre codés avec hamming , car le medium peut tous changer ?,
merci