NATIONAL UNIVERSITY OF HO CHI MINH CITY

TECHNISCHE UNIVERSITÄT
···☼···

BERICHT ÜBER DIE GROSSE ARBEIT

FACH: LINEARE ALGEBRA

THEMA:
MÃ HAMMING (7,4)
FEHLER ERKENNEN UND BEHEBEN

GVHD: Nguyễn Xuân Mỹ

Ho-Chi-Minh-Stadt, Dezember, 2023

 Vorname und Nachname MSSV
Trần Thành Minh 2312127
Nguyễn Nhật Nam 2312175
Huỳnh Nga 2111818
Phạm Hữu Trọng Nghĩa 2312277
Trần Đại Nghĩa 2312281
Nguyễn Minh Bảo Ngọc 2312312
Nguyễn Công Nguyên 2312359
Nguyễn Mạnh Thành Nhân 2312434
 INHALT
Lờich Mở Đầu......................................................................................................................

[Link]ý Thùyế.......................................................................................................2

1. Hamming-Code: ....................................................................................................2

2. Hamming-Code (7,4): ...........................................................................................3

3. Ma trận tạo mã: ..................................................................................................4

4. Ma trận kiểm tra:................................................................................................4

II. Wie man sử dụHamming-Code:..............................................................................5

1. Sử dụng thuật rechnen mit Matrizenận: ...............................................................................5

2. Sử dụHamming-Code bErgänzen, umkiScheck Schuleng hợp hai lỗi: .......................7

[Link] man Codes erstellt – Überprüfung & Fehlerbehebung:...................................................................8

1. Wie man einen Code erstellt:......................................................................................................8

2. Überprüfen und Fehler beheben:.............................................................................................9

[Link] erklären: ..................................................................................................10

IV. Kết quả: ..............................................................................................................15

Lờich kết ...............................................................................................................................

V. Tài liệu tham khảo:...........................................................................................18

 BILDERVERZEICHNIS
Bild 1 Code tạo ma trận tạo mã và ma trận kiểm tra.............................................11
Abbildung 2 Code tạo dữ liệu nhị Teil..............................................................................11
Abbildung 3 Code tạo ma trận Hamming wähle dữ liệu.......................................................12
Abbildung 4 Code tạo lỗich wähle das Materialận................................................................................12
Abbildung 5 Code kiểm tra und sửa lỗich bin trận ..................................................................13
Abbildung 6 Code kiểm tra lỗich củeinen Ma trận .......................................................................13
Abbildung 7 Code sửein lỗIch wähle Matheận................................................................................14

Abbildung 8 Code tạo ma trận dữ liệu đầu ra...................................................................14

Abbildung 9 Code wechselnển dữ liệu từ dang binary về ký tự und gehenất kết quả...................14
Abbildung 10 Nhập ch‘dstt’ in den Code eingeben..................................................15
Abbildung 11 Chọn vị drei mirốn sai. (vd: hàng 1 cột 1).....................................................15
Abbildung 12 Entwicklungện lỗi sai và sửein.................................................................................16
 Einleitung
Heute entwickelt sich die Technologie rasant, die Bedürfnisse der Menschen
über die zunehmende Informationsübertragung von Menschen. Allerdings im Bereich
Computing, die meisten Arten von Daten einschließlich numerischer Daten, Zeichendaten oder Bilddaten werden von der Maschine

Speicherung und Verarbeitung in Form von Code der Binärzahlen 0 und 1. Die Datenkodierung von Form

Die Umwandlung von Dezimalzahlen in Binärzahlen lässt die Daten größer und schwerer zu kontrollieren werden. Zum Beispiel wie
sốmột wird vom Computer in die 4-Bit-Daten "0001" codiert, um gespeichert und später verarbeitet zu werden.
naja. Ähnlich sind die Buchstaben in einer bestimmten Anzahl im ASCII-Code festgelegt und von
Die ASCII-Codes werden in binäre Form umgewandelt. Aus dem oben genannten Beispiel..
Die Daten, die ein Computer normalerweise speichern und verarbeiten muss, können Tausende von Bits betragen.
Tausende von 0/1). Daher wird der Computer häufig die Daten falsch lesen, die
Bit-Fehler werden dazu führen, dass der gesamte ursprüngliche Datensatz falsch wird. Um Fehler zu beheben

Darüber hinaus wurden Algorithmen zur Überprüfung und Behebung von Fehlern entwickelt und weiterentwickelt, wobei insbesondere hervorgehoben wird

einschalten mit Hamming-Code.

1
 I. Theoretische Grundlagen:
Hamming-Code:
Der Hamming-Code ist ein System zur Kodierung und Fehlerüberprüfung, das ursprünglich von
Richard Hamming in den 1950er Jahren. Seit seiner Entdeckung und Darstellung hat es...
Praktisch, es wird häufig verwendet, um Fehler in Datenbitfolgen zu erkennen und zu korrigieren. Kurz gesagt.
Gleitend, der Hamming-Code bietet uns eine Methode zur Fehlererkennung und -korrektur, die durch
die folgenden Schritte:

Ursprüngliche Datenverschlüsselung (durch Hinzufügen von Spezifikationen der ursprünglichen Daten) → Übertragung

Information gehen → Daten erhalten und überprüfen → Daten zurückgeben.

Der Hamming-Code wird normalerweise in der Form (n, k) dargestellt. Das bedeutet, dass die Eingabedaten von

Wir werden eine Kette aus k Bits in binärer Form haben, diese Daten werden kodiert mit
Die Methode zur Hinzufügung von (n-k) entsprechenden Bits. Danach werden diese n Bits analysiert und verglichen, um zu wissen

Gab es irgendwelche Fehler?

k Bits n-k Bits

k: Anzahl der bedeutenden Bits.

n-k: Anzahl der hinzugefügten Prüfbits.

Das bedeutet, dass wir längere Sequenzen übertragen oder speichern können, um die Integrität zu gewährleisten.

Vervollständigung der Daten. Es gibt viele Varianten des Hamming-Codes, darunter die gängigsten Varianten.
Am häufigsten ist der Hamming-Code (7,4), sowie der Hamming-Code (15,11) und der Hamming-Code.
(31,26). Seit seiner Entwicklung hat der Hamming-Code seine Überlegenheit gegenüber anderen Codes gezeigt.

Überprüfung vorher, wie Paritätscode (kann nur einen Bitfehler erkennen und kann ihn nicht beheben
(Fehler), Wiederholungs-Code (verbraucht viel Speicherplatz, geringe Effizienz bei der Fehlerbehebung).

Der Hamming-Code wird häufig in Bereichen eingesetzt, die hohe Genauigkeit und Zuverlässigkeit erfordern.

hohe Zuverlässigkeit bei der Übertragung und Analyse von Daten. Ein Anwendungsbereich nutzt den Hamming-Code:

Kommunikation und Netzwerke, Datenübertragung, drahtlose Kommunikation, Satellitenkommunikation, Sicherheit

und verschlüsseln...

2
 2. Hamming-Code (7,4):
Ähnlich wie in der genannten Theorie ist der Hamming-Code (7,4) eine spezifische Art von Hamming-Code.

Entwurf zur Kodierung eines 4-Bit-Datenstroms in einen 7-Bit-Datenstrom, der 4 Bit der ursprünglichen Daten enthält.
Kopf und 3 Prüfbits. Der Hamming-Code (7,4) wird verwendet, um Fehler zu erkennen und zu korrigieren in
Eine 4-Bit-Datenreihe, die während der Datenübertragung oder -speicherung integriert ist
um die Integrität zu gewährleisten. Und in diesem Artikel betrachten wir nur den Körper zur Basis 2 (oder System

Zweiphasig)

Ich habe 4 ursprüngliche Datenbits: d1, d2, d3, d4.

Die gerade und ungerade Zahl wird gemäß der Regel erstellt:

p1= d1 + d2 + d4

p2 = d1 + d3 + d4

p3 = d2 + d3 + d4

p4 = d1 + d2 + d3

Das bedeutet, dass wir 3 aus den 4 genannten Kombinationen verwenden können, um ein Paritätsbit zu erzeugen. Zum Beispiel verwenden wir die Kombination
p1, p2, p3 kombinieren.

Die geraden und ungeraden Bits p1, p2, p3 werden erzeugt, indem die Parität der Anzahl der 1-Bits berechnet wird.

Dabei muss in jedem Kreis die Anzahl der 1-Bits gerade sein.

Von dort aus haben wir einen Code, der aus 7 Bits besteht und die Form hat: p1p2d1p3d2d3d4.

3
 p1 p2 d1 p3 d2 d3 d4
Allerdings können wir die geraden und ungeraden Bits an beliebigen Positionen in den Zellen platzieren, sie können erstellen

unterschiedliche Zahlenfolgen, die jedoch Hamming-Codes sind und als ähnlich betrachtet werden.

Dort.

3. Codeerstellungs-Matrix:

Der Hamming-Code (7,4) verwendet eine Matrix, um einen Code zu erstellen, um Daten aus einer Bitreihe zu übertragen.

4 Bit werden verwendet, um eine Datenbitfolge von 7 Bit mit 3 hinzugefügten Prüfbits zu erstellen.

Mit einem Datenvektord4×1, die Generatormatrix G wird seinG7×4Wir beginnen mit der Erstellung der Matrix G
indem

1. Ordne die Datenbits der Reihe nach in einem Zeilenvektor an.

d11 0[ 0 0; d2]=010 0;[ d3 =0 ]010d40[0 01. ] [ ]

2. Ordnen Sie die geraden und ungeraden Bits der Reihe nach in einem Vektor an (wobei die Einsen an den Positionen liegen)

entsprechend den Datenbits

p3011
[ 1; p2 =1
] 01 1; [p1 =1 101.
] [ ]

Daraus erhalten wir die Hamming-Codiermatrix (7,4) in diesem Fall:

10 0 0
01 0 0
0 01 0
G = 0 0 01
01 11
1011
[11 01 ]

Anders ausgedrückt, kann die Matrix G aus einer Einheitmatrix erstellt werden.Ich4und die Matrix

gerade ungeradeP.
3×4

4. Prüfmatrix:
Der Hamming-Code (7,4) verwendet eine Prüfmatrix, um Fehler zu erkennen und in der Sequenz zu korrigieren.

Hamming-Code.

Testmatrix H für Datenvektorend4×1wird die Form habenH3×7.

4
Unten steht die Prüfmatrix des Hamming-Codes (7,4):

0 0 01 11 1
H=[ 01 10 011 ]
1010101

Dabei entspricht jede Zeile von H p3, p2, p1. Die Zahl 1 wird in die Positionen eingetragen.
entspricht dem geraden und ungeraden Bit. Zum Beispiel p3 = d2 + d3 + d4, wobei wir in einem 7-Bit-Code sehen, dass die Position

Die Werte von p3, d2, d3, d4 sind jeweils 4, 5, 6, 7. Somit erhalten wir den Zeilenvektor p3 =[0 0 011 11 . ]

II. Verwendung des Hamming-Codes:

1. Verwenden Sie den Matrizenalgorithmus:

Das Grundprinzip des Hamming-Codes (7,4) besteht darin, dass zur Übertragung von 1 Daten, die aus 4 Bits bestehen, zuerst

Der Generator wird einen Algorithmus verwenden, um diese Daten in Daten mit 7 Bit umzuwandeln, von denen 4.

Die ursprünglichen bits und 3 zusätzliche bits zur Überprüfung. Danach werden die Daten an den Empfänger übertragen.

Die Empfangsmaschine wird einen Algorithmus verwenden, um zu überprüfen, ob die Daten fehlerhaft sind. Wenn ja, wird sie sich selbst ...

Fehlerbehebung (Fall, in dem nur 1 Bit fehlerhaft ist).

Hinweis: Der Hamming-Code (7,4) kann nur 1 Bit Fehler erkennen und korrigieren, im Falle von

Um mehr Fehler zu beheben, können wir stärkere Fehlerkorrekturcodes verwenden. Ein Beispiel sind die
Varianten des erweiterten Hammingcodes wie (15,11) oder (31,26).
Möglichkeiten zur Überprüfung und Behebung von Fehlern mit Hilfe von Codewort-Matrizen und Prüfmatrix:

Gruppiere vier Bit Daten zu einem Spaltenvektor, um die Daten übertragen zu können. Zum Beispiel benötigte Daten

Wenn die Übertragung "0110" ist, haben wir den Vektor P als:
0
P[ ] 1
1
0

Um das Bit-Segment zu übertragen, multiplizieren wir G und P miteinander im Binärsystem, das Ergebnis ist
wird der Vektor r:

10 0 0 0
01 0 0 1
0
0 01 0 1
G. P= 0 0 01 1
[ ]= 0 = r
1
01 11 0
0
1011 1
[11 01 ] [1]
5
Die Daten werden weiterhin übertragen, um zu überprüfen, ob Fehler auftreten. Daher werden wir tatsächlich
das Produkt von H und r:

0
1
0 0 01 11 1 1 0
H.r[ 01 10 011 0 ] = [ 0]
1010101 0 0
1
[1]

Durch die Multiplikation von H und r ergibt sich ein Vektor, der ganzzahlig ist, daher kann die Maschine zu dem Schluss kommen, dass es nicht so ist.

Es ist ein Fehler aufgetreten.

Um zu erklären, dass ein ganzzahliger Vektor nicht mit der Schlussfolgerung übereinstimmt, ist fehlerfrei,

weil beim Multiplizieren der Matrix G mit dem Datenvektor eine Veränderung in der Grundlage auftritt

mit dem inneren Raum des Vektors (Vektorsubraum), das heißt, der Kern der Prüfmatrix H.
Wenn im Raum des Vektors r keine Probleme auftreten, bleibt r an derselben Stelle.
Im Kern der Matrix H und der Multiplikation von H mit r wird ein Vektor mit nur Nullen erzeugt.

Zum Beispiel in einem anderen Fall nehmen wir an, dass ein Bitfehler aufgetreten ist. In der Mathematik haben wir

kann schreiben:

Darunter Es ist der Einheitsvektor an der ersten Position. Das bedeutet, dass im Vektor r eine Zeile mit einem Wert vorhanden ist.

1 statt 0 oder umgekehrt. Dadurch können wir leicht die Position des fehlerhaften Bits erraten.
passieren

Das Beispielvektor, das wir erhalten haben, tritt an der Position drei auf einen Fehler auf.

0
1
0
=> ′= + 3 = 0
0
1
[1]

Als nächstes führen wir die Multiplikation von H und r' durch, dann erhalten wir:

6
 0
1
0 0 01 11 10 0
Hr’=[ 01 10 011 0 ] = [ ]1
10101010 1
1
[1]

0
Die Multiplikation von Hr' ergibt uns das Ergebnis[ ]
1entspricht der dritten Spalte ("011" entspricht
1
Mit dem Wert 3 an der dritten Dezimalstelle wissen wir, dass ein Fehler an der dritten Stelle aufgetreten ist.
In den Datenzeilen können wir den Fehler dann beheben.

2. Verwenden Sie den Hamming-Code zur Überprüfung des Falls mit zwei Fehlern:

Der Hamming-Code ist ein Code, der in der Lage ist, einen einzelnen Fehler zu erkennen und zu korrigieren, jedoch kann er nicht unterscheiden.

biệt Fehler bei Doppel-Bits eines Codeworts mit einem Einzel-Bit-Fehler eines anderen Codeworts. Daher einige Fehler

Das Bitbild wird aufgrund dieser Verwechslung nicht korrekt decodiert, was ein Einzelbitfehler ist, der nicht auftritt.

pháthiện, trừ khi chúng ta không cố gắng tìm ra và sửa nó. Để khắc phục tình trạng
Dieser Fehler kann durch einen zusätzlichen Paritätsbit im Hamming-Code an der Position erweitert werden.

Acht, um den Fall von zwei Fehlern zu überprüfen.

Beispiel für die Verwendung der Fehlerkorrekturfunktion des Hamming-Codes: Wenn ein Fehler an einer beliebigen Stelle auftritt, die

Wenn gerade und ungerade Bit gleichzeitig erkannt werden und der Hamming-Code anzeigt, dass ein Fehler aufgetreten ist, dann haben wir

um diesen Fehler zu beheben, wenn das Paritätsbit keinen Fehler erkennen kann, aber der Hamming-Code
Das Signal zeigt an, dass ein Fehler aufgetreten ist, von dem wir ableiten können, dass dieser Fehler durch 2 Bits verursacht werden könnte.

Fehler gleichzeitig. Allerdings, im Falle eines Auftretens von zwei Bits-Fehlern, entdecken wir
Es ist ein Fehler aufgetreten, aber der Fehler kann nicht behoben werden.

VD: Überprüfung des Fehlers des Bitabschnitts: 1001010

Fügen Sie 1 Bit für Parität am Ende hinzu, damit es zwei Fehler in 7 Bit erkennen kann.
còn lại. Da 1001010 hat 3 Einsen, was eine ungerade Zahl ist, daher ist das Parität-Bit an der achten Stelle 1, deshalb erhalten wir:

1001010 => 10010101

7
 Position 1 2 3 4 5 6 7 8
Empfangscode 1 0 0 1 0 1 0 1
Überprüfung der Parität an der Position
1 0 0 0 c1=1
trí 1-3-5-7
Überprüfung der Parität an der Position
0 0 1 0 c2=1
trí 2-3-6-7
Überprüfung der Parität an der Position
1 0 1 0 c3=0
trí 4-5-6-7

Erklärung:

Nachdem wir den 8-Bit-Code erhalten haben, beginnen wir, die Parität an den Positionen 1-3-5-7 zu überprüfen.

Die Zahl 1000 hat eine ungerade Ziffer, daher c1= 1

Setzen Sie die Überprüfung der Parität an den Positionen 2-3-6-7 fort, entsprechend 0010. Da es eine 1 gibt, ist die Zahl ungerade, daher

c 2= 1
Ähnlich überprüfen wir die Parität an den Positionen 4-5-6-7 entsprechend 1010, da die Anzahl der 1en eine Zahl ist

Die Zahl 2 ist gerade, also c3= 0

• Überprüfung der Parität des gesamten Codes 10010101: 0 (da die Anzahl der Einsen 4 ist, ist die Zahl
gerade) => Code ohne Fehler oder mit zwei Fehlern

• C = 011 = 3≠ 0

Schlussfolgerung: Das Bitmuster 1001010 wurde durch einen Fehler in zwei Bits verursacht.

III. Methode zur Erstellung von Code – Überprüfung & Fehlerbehebung:

[Link] man einen Code erstellt:

Gib die Daten a =1[ 101und]die Matrix G hat Zeilenvektoren

11 10 0 0 0
G[ 11 01 10 0 ]
01 01 01 0
10 010 01

Um einen Hamming-Code zu erstellen, führen wir die Berechnung r1 = a.G durch =1 01

[ 01 01 ]

8
 [Link]üfung & Fehlerbehebung:
Die Matrix H hat die Form:

0 0 01 11 1
H =[ 01 10 0 11 ]
1010101

Wenn wir einen Code r2 = [erhalten1 01 01

] 11 Um Fehler auf der Grundlage einer Matrix zu überprüfen und zu beheben
Um oben genanntes umzusetzen, führen wir die folgenden Schritte durch:

Schritt 1: Vektordaten w mit der Inversen der Prüfmatrix H multiplizieren

Schritt 2: Überprüfen Sie den Ergebnisvektor:

-Wenn der Vektor e gleich 0 ist, tritt kein Fehler auf.

-Wenn der Vektor e ungleich 0 ist, ist ein Fehler aufgetreten, und der Fehlerort muss bestimmt werden.

0 01
01 0
01 1
Ta có: e = r2.H’=1[01 01 11 ] 10 0 = 1[10→ Ein
] Fehler ist aufgetreten → Position sechs.
101
11 0
[11 1 ]

Der Fehler tritt im 6. Bit des Vektors r2 auf. Wir beheben den Fehler, indem wir den Wert des fehlerhaften Bits ersetzen.
6 von 1 bis 0.

Der korrigierte Hamming-Code ist r3= 1 01 01 01 [ ]

Die anfänglichen Informationen sind a [=1 101von

] den Elementen 3, 5, 6, 7 von w1.

9
 [Link]äuterung des Codes:

Die verwendeten Befehle:

Befehl Wirkung
[ A; B; C] Erstellen Sie eine Matrix mit den Zeilen A, B, den Elementen auf jeder.
Waren durch ein Leerzeichen voneinander getrennt

Variable name = Eingabe ( 'promt', 's') Verwenden Sie, um einen Wert einzugeben

Eingabe 'promt' ist die Zeichenfolge, die eingegeben werden soll

‘s’ gibt an, dass der Eintrittspreis viele Zeichen ist

dec2bin(n, stelle) Verwendet, um eine Zeichenkette in Binärcode umzuwandeln

n: Variable, die Zeichenkette enthält

Ort: Bibliothek
reshape(a,m,n) Die Größe der Matrix umformatieren
Die Matrix muss neu formatiert werden
m,n: Anzahl der Zeilen und Spalten nach der Neugestaltung

Disp('a') Gib „a“ auf dem Bildschirm aus

für die Steuervariable = Startwert: Endwert, Wird verwendet, um eine wiederholte Aufgabe gemäß 1 auszuführen

Die Arbeit erledigen; Regel, mit einer im Voraus festgelegten Anzahl von Schritten.

Ende
num2str(b) Konvertiere die Gleitkommazahl in einen String
Ändern Sie die Zeichen in einer Zeichenkette in ihre Reihenfolge
entsprechend im ASCII-Code
Name der zu ändernden Variablen

mod (Dividende, Divisor) Modulobetrag (Restwert nehmen)

D= Größe(x) D: Zeilen- und Spaltenanzahl der Matrix x
M= Größe(x,1) M: Anzahl der Zeilen der Matrix x

N = Größe(x,2) N: Schockt Mätrün x

Y = beliebig(x) Überprüfen Sie, ob der Vektor oder die Matrix unterschiedliche Werte hat
nicht oder nicht
Y = 1: gibt es ein anderes Element nicht

10
 Y =0: keine anderen Elemente ungleich null

bin2dec(n) Konvertierung von Binär zu Dezimal

zeichen(x) Umwandlung in eine Zeichenkette

Abbildung 1: Code zur Erstellung der Codematrix und der Prüfmatrix

Erstellen Sie zwei Matrizen für den Code G und die Prüfmatrix H.

Abbildung 2 Code zur Erstellung von Binärdaten

Erstellen Sie eine Variable str und erfassen Sie die eingegebenen Daten.

Erstellen Sie eine binäre Matrix mit 4 Spalten und speichern Sie sie in der Matrix a.

11
 Abbildung 3 Code zur Erstellung einer Hamming-Matrix für Daten

Erstellen Sie eine Hamming-Matrix für die eingegebenen Daten. Indem Sie jede Zeile der Matrix a multiplizieren.
mit der Matrix G.

Die erzeugte Matrix wird in der Matrix v gespeichert.

Geben Sie die gerade erstellen Hamming-Code-Matrix auf dem Bildschirm aus.

Abbildung 4 Code, der einen Fehler für die Matrix erzeugt

Erstellen Sie die Variable x, um den Wert für die Position zu erhalten, an der Sie einen Fehler erstellen möchten.

Nacheinander die Werte der Bits an den gewünschten Positionen in der Matrix v umkehren.

Geben Sie die Matrix auf dem Bildschirm aus, nachdem ein Fehler aufgetreten ist.

12
 Abbildung 5 Code zur Überprüfung und Fehlerbehebung von Matrizen

Abbildung 6 Fehlerprüfcode für Matrizen

Erstellen Sie eine Schleife, die von 1 bis zur Anzahl der Zeilen der Matrix v läuft.

Erstelle einen Vektor r und weise den einzelnen Zeilen der Matrix v die Werte des Vektors r zu.

Berechne den Vektor s (Fehler-Syndrom), indem du den Vektor r mit der inversen Matrix H multiplizierst.

Setze b mit b=any(s), wenn der Vektor s ungleich 0 ist, dann ist b=1, andernfalls ist b=0;

13
 Abbildung 7 Fehlerbehebungscode für die Matrix

Wenn b ungleich 0 ist oder anders gesagt, wenn der Vektor s (Fehler-Syndrom) ungleich 0 ist, dann führe die folgenden aus
Befehl folgend:

Berechne err_p (die Reihenfolge der Spalte mit Fehlern).

Erstellen Sie den Vektor pos als Position des Fehlers, Zeile i und Spalte err_p.

Geben Sie den Wert des Vektors pos auf dem Bildschirm aus.

Ändern Sie den Wert des fehlerhaften Bits an der Position Zeile i, Spalte err_p in der Matrix v.

Ende des If-Blocks.

Abbildung 8 Code zur Erstellung eines Datenmatrixausgangs

Erstelle den Vektor k mit den Werten, die nacheinander die Elemente der i-ten Zeile der Matrix an den Positionen 3, 5, 6, 7 sind.

Erstellen Sie eine Matrix d und geben Sie nacheinander die Werte des Vektors k(i) in jede Zeile ein.

Ende der Schleife.

Abbildung 9 Code zur Umwandlung von Daten im Binärformat in Zeichen und Ausgabe des Ergebnisses

14
Geben Sie die Matrix auf dem Bildschirm aus, nachdem Sie den Fehler v behoben haben.

Konvertiere die Daten im Binärformat zurück in das ursprüngliche Zeichenformat und speichere sie in der Variablen t.

Geben Sie das Ausgangsbild t aus, es sind die Daten, die nach der Fehlerbehebung erhalten wurden.

[Link]

Bild 10 Geben Sie den Text 'dstt' in den Code ein

Abbildung 11 Wählen Sie die Position, die Sie auswählen möchten. (z. B.: Reihe 1 Spalte 1)

15
Abbildung 12 Fehlererkennung und -korrektur

16
 Schlusswort
Durch dieses große Projekt zum Thema Hamming-Code (7,4) erfahren wir mehr über den Hamming-Code, ein
Die Methode zur Kodierung von Informationen für die Übertragung und Speicherung von Daten. Der Hamming-Code hilft uns

Es gibt Stabilität im Übertragungsprozess, was Abweichungen durch die Störung von Bits minimiert.
Zweiersystem verursacht. Genauer gesagt, in diesem Thema wissen wir, wie man codiert.
Überprüfen und Korrigieren von Fehlern im Hamming-Code 7,4 mittels der Verwendung der Erzeugungsmatrix.
Die Testmatrix, wie man ein vollständiges Programm zur Beschreibung des Prüfverfahrens durchführt.
Überprüfen und Korrigieren von Fehlern mit der Hamming 7,4 Methode in der Software Matlab. Außerdem fügen wir hinzu,

Es ist bekannt, wie der Hamming-Code Fehler erkennt, die durch die Abweichung von 2 Datenbits verursacht werden.
Durch Forschung und Untersuchung bleibt der Hamming-Code 7,4 immer noch unpraktisch, da er nicht in der Lage ist.

Mehr als einen Fehler beheben und mehr als zwei Fehler erkennen, ist ungeeignet, um mit Daten umzugehen.
Es gibt jedoch große Größen. Zusammenfassend lässt sich sagen, dass der Hamming-Code 7,4 weiterhin Nachteile hat,
Es zeigt weiterhin die Zuverlässigkeit in der Kommunikation und der Datenspeicherung.
und wird häufig in vielen Anwendungen verwendet, die Genauigkeit und Integrität erfordern
hochwertige Daten.

17
Literaturverzeichnis:
1. Đặng Văn Vinh, Lehrbuch der linearen Algebra, 2019, Kapitel 3.
2. David Houcque, Einführung in Matlab für Ingenieurstudierende, 2005.
3. Richard Tervo, Hamming-Code, 2011
Invalid request. Please provide text to be translated.

18