Vous êtes sur la page 1sur 3

CRC CODE :

En langage C :

Les codes de redondance cyclique font partie des meilleures sommes de contrôle disponibles pour
détecter et / ou corriger les erreurs dans la communication et transmissions. Malheureusement,
l'arithmétique modulo-2 utilisée pour calculer les CRC ne correspond pas facilement au logiciel.
Un CRC est un type de somme de contrôle puissant capable de détecter la corruption de données
stockées et / ou transmises entre ordinateurs. De manière générale, les CRC sont calculés plus
efficacement dans du matériel dédié. Cependant, vous devez parfois calculer un CRC dans un logiciel,
par exemple dans un programme C ou C ++ qui s'exécutera dans un système intégré.

Avant d'écrire une seule ligne de code, examinons d'abord les mécanismes de la division binaire
modulo-2. Nous utiliserons l'exemple suivant pour nous guider. Le nombre à diviser est le message
augmenté de zéros à la fin. Le nombre de bits nuls ajoutés au message est identique à la largeur de la
somme de contrôle, dans ce cas, quatre bits ont été ajoutés. Le diviseur est un nombre de c + 1 bits
appelé polynôme générateur.

Le processus de division modulo-2 est défini comme suit:


- Appelez les bits c + 1 les plus hauts du message, le reste
- En commençant par le bit le plus significatif du message d'origine et pour chaque position de
bit qui suit, regardez le reste du bit c + 1:
°Si le bit le plus significatif du reste est un, le diviseur est divisé en deux. Si cela se produit (comme
dans toute autre division longue), il est nécessaire d'indiquer une division réussie dans la position de
bit appropriée dans le quotient et de calculer le nouveau reste. Dans le cas de la division binaire
modulo-2, on se contente de:
- Définir le bit approprié du quotient sur un, et XOR le reste avec le diviseur et stocke le
résultat dans le reste
°Sinon (si le premier bit n'est pas un):
- Définir le bit approprié du quotient à zéro, et XOR le reste avec zéro (pas d'effet)
°Déplacez le reste à gauche, en vous déplaçant dans le bit suivant du message. Le bit décalé sera
toujours un zéro, ainsi aucune information n'est perdue.
La valeur finale du reste est le CRC du message donné.
Le programme en langage C :
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
int i,j,keylen,msglen;
char input[100], key[30],temp[30],quot[100],rem[30],key1[30];
clrscr();
printf("Enter Data: ");
gets(input);
printf("Enter Key: ");
gets(key);
keylen=strlen(key);
msglen=strlen(input);
strcpy(key1,key);
for(i=0;i<keylen-1;i++)
{
input[msglen+i]='0';
}
for(i=0;i<keylen;i++)
temp[i]=input[i];
for(i=0;i<msglen;i++)
{
quot[i]=temp[0];
if(quot[i]=='0')
for(j=0;j<keylen;j++)
key[j]='0';
else
for(j=0;j<keylen;j++)
key[j]=key1[j];
for(j=keylen-1;j>0;j--)
{
if(temp[j]==key[j])
rem[j-1]='0';
else
rem[j-1]='1';
}
rem[keylen-1]=input[i+keylen];
strcpy(temp,rem);
}
strcpy(rem,temp);
printf("\nQuotient is ");
for(i=0;i<msglen;i++)
printf("%c",quot[i]);
printf("\nRemainder is ");
for(i=0;i<keylen-1;i++)
printf("%c",rem[i]);
printf("\nFinal data is: ");
for(i=0;i<msglen;i++)
printf("%c",input[i]);
for(i=0;i<keylen-1;i++)
printf("%c",rem[i]);
getch();
}
Avec Matlab :

Le CRCGenerator génère des bits de code de redondance cyclique (CRC) pour chaque trame de données
d'entrée et les ajoute à la trame. L'objet s'attend à ce que l'entrée soit un vecteur de colonne binaire. Le type de
données doit être double ou logique. Si le type de données en entrée est double, le bit le moins significatif est
utilisé comme valeur binaire.

Pour générer des bits de code de redondance cyclique et les ajouter aux données d'entrée:

- Définir et configurer le générateur de CRC.


- Appeler l'étape pour générer des bits de code de redondance cyclique (CRC) pour chaque trame de
données d'entrée en fonction des propriétés du détecteur de CRC.

Exemple : voici le polynôme générateur du CRC 8 - P(x) = x8+ x2+ x1+ x0

Circuit générateur du CRC 8

function ret = crc32(bits)


poly = [1 de2bi(hex2dec('EDB88320'), 32)]';
bits = bits(:);

% Flip des 32 premiers bits


bits(1:32) = 1 - bits(1:32);
% Ajout de 32 zéros à la fin
bits = [bits; zeros(32,1)];

% Initialisation du ‘Reminder’a 0
rem = zeros(32,1);
% Boucle de calcul principale pour le CRC32
for i = 1:length(bits)
rem = [rem; bits(i)];
if rem(1) == 1
rem = mod(rem + poly, 2);
end
rem = rem(2:33);
end

% Flip du ‘Reminder’  avant de le retourner


ret = 1 - rem;
end