IEEE802.3 Frame - IEEE802.3 Frame

IEEE802.3 Frame

Autres catégories

1.0.1

Télécharger

IEEE 802.3 Encapsulation du cadre Ethernet

sujet

IEEE 802.3 Encapsulation du cadre Ethernet

Écrivez des programmes pour mettre en œuvre l'encapsulation de la trame Ethernet IEEE 802.3.

Exigences de base:

Il est nécessaire de dessiner l'interface et la partie de données, l'adresse MAC source et l'adresse MAC de destination de la trame Ethernet sont entrées de l'interface;
Le champ de somme de contrôle calculé et le résultat encapsulé peuvent être sortis de l'interface;
Générer du polynôme g (x) = x8 + x2 + x + 1;
Le système d'exploitation, le langage et l'environnement de compilation utilisés ne sont pas limités, mais doivent être notés dans le rapport.

Exigences prolongées:

Capable de visualiser le processus de calcul CRC;
Capacité à contrôler le fonctionnement du programme à partir de l'interface.

Connaissances théoriques connexes

La structure du cadre selon la norme 802.3 est indiquée dans le tableau suivant (la structure du cadre Ethernet de la norme 802.3 se compose de 7 parties)

802.3 Structure de trame standard

Code de plomb	Délimiteur pré-trame	Adresse de destination	Adresse source	Champ de longueur	Champs de données	Champ de vérification
7b	1b	(6b)	(6b)	(2b)	(Longueur variable)	(4b)

Parmi eux, la longueur minimale du champ de données de trame est de 46B. Si le cadre a moins de 46B, le champ de données doit être rempli à 46B. Le caractère de rembourrage est arbitraire et ne compte pas sur la valeur du champ de longueur.

Dans le champ de contrôle, le contrôle CRC est utilisé. La portée de la vérification comprend le champ d'adresse de destination, le champ d'adresse source, le champ de longueur et le champ de données LLC.

Analyse des exigences

Visualisation du module d'entrée utilisateur

Utilisez une interface visuelle pour recevoir l'adresse de destination, l'adresse source, le champ de longueur et le champ de données saisis par l'utilisateur. Il prend également en charge la génération de données aléatoires, ce qui peut réduire la saisie des utilisateurs

Calculez le champ de contrôle

Utilisez le polynôme généré pour calculer le champ de vérification des données à vérifier. Le champ à vérifier est un octet entier, l'ordre du polynôme généré ne dépasse pas 32 et le reste calculé est de 4 octets.

Entrez la visualisation du numéro binaire

Imiter le clavier d'entrée de bit de la calculatrice de Windows 10, permettant aux utilisateurs d'entrer et de générer des polynômes et d'autres données en cliquant sur la souris

Vérifiez les données de trame

Le cadre après le calcul de FCS se produit au récepteur, et le récepteur peut vérifier s'il y a une erreur. Vous pouvez simuler des erreurs, telles que la modification manuelle des données, puis vérifier s'il y a une erreur.

Visualisation du processus de calcul CRC

À l'aide de données binaires plus courtes, affichez dynamiquement le processus de calcul CRC et la fonction de vérification de support. Le temps de retard de chaque étape peut être personnalisé pour contrôler la vitesse d'affichage et la présentation peut être arrêtée à tout moment.

Calcul du code redondant cyclique

principe

Selon la formule suivante

$$ r ≡ (n * c + r) mod c \ $$

Peut obtenir

$$ 110 lons

Autrement dit, développer un nombre n fois, puis ajouter le reste. Pour le moment, le reste de $$ mod m $$ reste inchangé

graphique de flux

Implémentation de code

 private byte [ ] CalcCRC ( string v )
{
    var data = new Queue < char > ( v . ToArray ( ) ) ;    // 被除数
    char [ ] divisor = binaryString . ToArray ( ) ;    // 除数
    Queue < char > S = new Queue < char > ( ) ;          // 商
    int width = divisor . Length ;                 // 每次取 width 个字符进行异或运算
    Queue < char > str = new Queue < char > ( ) ;        // 每次取的长度为 width 的部分被除数

    // 获取前 width - 1 个字符，填入到str中
    for ( int i = 0 ; i < width - 1 ; i ++ )
    {
        str . Enqueue ( data . Dequeue ( ) ) ;
    }

    while ( data . Count != 0 )
    {
        str . Enqueue ( data . Dequeue ( ) ) ;

        if ( str . First ( ) == '0' )
        {
            S . Enqueue ( '0' ) ;
            str . Dequeue ( ) ;
        }
        else
        {
            S . Enqueue ( '1' ) ;

            var temp = str . ToArray ( ) ;
            str . Clear ( ) ;

            for ( int i = 1 ; i < temp . Length ; i ++ )
            {
                str . Enqueue ( temp [ i ] == divisor [ i ] ? '0' : '1' ) ;
            }
        }
    }
	// 计算已经结束，str中的值就是结果，下面的代码可以不用看了
    
    // 将str中的值转成4个字节的二进制数组
    var res = new string ( str . ToArray ( ) ) . PadLeft ( 32 , '0' ) ;
    var result = new byte [ 4 ] ;
    // 将字符串格式化为byte
    for ( int i = 0 ; i < 4 ; i ++ )
    {
        result [ i ] = Convert . ToByte ( res . Substring ( i * 8 , 8 ) , 2 ) ;
    }

    return result ;
}

Exemple d'application

Données en attente: 1010 0111 0110 0

Générer le polynôme: 1010 1101 0 ( $$ p (x) = x ^ 8 + x ^ 6 + x ^ 4 + x ^ 3 + x ^ 1 $$ )

Mettez toutes les données en attente dans data file d'attente
```
 data = [1010011101100]
```
Générez un polynôme de 9 bits, alors laissez d'abord les 8 premiers éléments des data file d'attente être désactivés et mettre les données dans la file d'attente str
```
 str  = [10100111]
data = [01100]
```
data.Count = 5 ! = 0, Continuez l'exécution
1. Déqueue le premier élément des data de file d'attente et les mettre dans la file d'attente str
```
 str  = [101001110]
data = [1100]
```
2. Le premier élément de str est 1
  1. Insérer 1 dans la colonne S
  2. Effectuez le biais exclusif ou de la valeur de la file d'attente str et la valeur du polynôme généré, et copiez les 8 derniers caractères du résultat à str 101001110 ^ 10101101010 = 000010100
```
 S    = [1]
str  = [00010100]
data = [1100]
```
data.Count = 4 ! = 0, Continuez l'exécution
1. Déqueue le premier élément des data de file d'attente et les mettre dans la file d'attente str
```
 S    = [1]
str  = [000101001]
data = [100]
```
2. Le premier élément de str est 0
  1. Insérez 0 dans la S et laissez la première déshabitation de str
```
 S    = [10]
 str  = [00101001]
 data = [100]
```
data.Count = 3 ! = 0, Continuez l'exécution
1. Déqueue le premier élément des data de file d'attente et les mettre dans la file d'attente str
```
 S    = [10]
str  = [001010011]
data = [00]
```
2. Le premier élément de str est 0
  1. Insérez 0 dans la S et laissez la première déshabitation de str
```
 S    = [100]
 str  = [01010011]
 data = [00]
```
data.Count = 2 ! = 0, Continuez l'exécution
1. Déqueue le premier élément des data de file d'attente et les mettre dans la file d'attente str
```
 S    = [100]
str  = [010100110]
data = [0]
```
2. Le premier élément de str est 0
  1. Insérez 0 dans la S et laissez la première déshabitation de str
```
 S    = [1000]
 str  = [10100110]
 data = [0]
```
data.Count = 1 ! = 0, Continuez l'exécution
1. Déqueue le premier élément des data de file d'attente et les mettre dans la file d'attente str
```
 S    = [1000]
 str  = [101001100]
 data = []
```
2. Le premier élément de str est 1
  1. Insérer 1 dans la colonne S
  2. Effectuez le biais exclusif ou de la valeur de la file d'attente str et la valeur du polynôme généré, et copiez les 8 derniers caractères du résultat à str 101001100 ^ 10101101010 = 000010110
```
 S    = [10001]
str  = [00010110]
data = []
```
data.Count = 0 == 0, fin, reste est str = 00010110 , le quotient est S = 10001
L'ensemble du processus de calcul est:

Effet

Ouvrir le programme

Générer des données aléatoires

Définissez le polynôme généré (ne pas régler le soi-même recommandé, car le polynôme généré que vous définissez peut ne pas convenir, augmentant ainsi le taux d'erreur de vérification)