<\/p>\n
Im ersten Teil dieser Beitragsreihe haben wir bereits den Ausdruck codiert, der später in Form eines QR-Codes grafisch abgebildet werden soll. Der weitaus interessantere Teil folgt noch: Die Berechnung des Fehlerkorrekturcodes. Schließlich folgt dann im letzten Teil der Beitragsreihe noch die Erstellung der eigentlichen Grafik, die Sie dann beispielsweise als Bilddatei speichern und etwa in einem Bericht einer Access-Datenbank weiterverwenden können. <\/b><\/p>\n
Der Stand nach dem ersten Teil der Beitragsreihe ist, dass wir eine codierte Zeichenkette vorliegen haben – unabhängig davon, ob diese als Zahl, als reiner Text oder als alphanumerische Zeichenkette daherkommt. Außerdem haben wir eine Möglichkeit geschaffen, den Grad der Fehlerkorrektur auszuwählen und die Version, also die Kantenlänge des zu erzeugenden QR-Codes. Dieser wird schließlich bereits aus der Länge der zu kodierenden Zeichenkette, dem Fehlerkorrekturgrad und der Codiermethode ermittelt.<\/p>\n
Als Nächstes benötigen wir den Fehlerkorrekturcode. Um diesen zu ermitteln, legen wir zunächst die Länge des Fehlerkorrekturcodes fest. Dies geschieht mithilfe einer Tabelle namens tblNumberOfDataCodewords<\/b> (Entwurf siehe Bild 1). Die Tabelle liefert die folgenden wichtigen Informationen, wobei wir den Datensatz aus der Tabelle nutzen, dessen Felder VersionID <\/b>und ErrorCorrectionLevelID <\/b>für unsere Codierung zutreffen (s. Bild 2):<\/p>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2014_04\/pic_947_001.png\")
<\/p>\n
Bild 1: Entwurf der Tabelle tblVersions<\/span><\/b><\/p>\n Bild 2: Die Tabelle tblVersions mit einigen Werten<\/span><\/b><\/p>\n Wenn wir also beispielsweise für VersionID<\/b> den Wert 5 <\/b>und für die Fehlerkorrektur den Level Q <\/b>ausgewählt haben, haben wir zwei Gruppen, wobei die erste zwei Blöcke mit je 15 Codewörtern aufnimmt und die zweite zwei Blöcke mit je 16 Codewörtern. Wenn Sie also beispielsweise einen Text codieren, der mit den oben genannten Parametern um einen Fehlerkorrekturcode erweitert werden soll, wird dieser Text 2 x 15 x 8 + 2 x 16 x 8 Zeichen lang sein, also 496 Zeichen lang sein – was auch der Fall ist. Wir brechen dies auf ein einfacheres Beispiel herunter, zum Beispiel zur Codierung der Zeichenkette HELLO WORLD<\/b>. Wir verwenden den Fehlerkorrekturgrad M und die kleinste Version mit 21 x 21 Zeichen. Die codierte Zeichenfolge sieht nach der Beschreibung aus dem ersten Teil der Beitragsreihe so aus:<\/p>\n 0010000001011011000010110111100011010001011100101101110001001101 Die Tabelle tblNumberOfDataCodewords <\/b>liefert die Information, dass diese Zeichenfolge in eine Gruppe mit 16 Blöcken \u00e1 acht Zeichen aufgeteilt wird, also etwa so:<\/p>\n Diese Zahlen benötigen wir später, wenn wir ein Polynom für den zu codierenden Text erstellen müssen. Die Zahlen dienen dann als Koeffizienten.<\/p>\n Steuerung der Codierung<\/b><\/p>\n Die Codierung starten Sie mit einem Klick auf die Schaltfläche cmdAktualisieren<\/b> des Formulars frmQRCodes<\/b>, das nun wie in Bild 3 aussieht. Dieses Formular erlaubt, wie schon im ersten Teil erläutert, die Eingabe des zu codierenden Textes in das Textfeld txtAusgangstext<\/b>, die Auswahl des Zeichensatzes mit dem Kombinationsfeld cboModeID<\/b>, den Grad der Fehlerkorrektur mit cboErrorCorrectionID<\/b> und die Version beziehungsweise Kantenlänge mit cboVersionID<\/b>.<\/p>\n Bild 3: Das Formular frmQRCodes<\/span><\/b><\/p>\n Die Schaltfläche cmdAktualisieren <\/b>löst nun die Prozedur aus Listing 1 aus. Diese erledigt zunächst die bereits im ersten Teil der Beitragsreihe beschriebenen Aufgaben, sprich: den binären Code zu ermitteln, welcher die Information über die Codierung, die Anzahl der Zeichen und den Text selbst in binärer Form enthält.<\/p>\n Listing 1: Diese Prozedur steuert die komplette Codierung.<\/span><\/b><\/p>\n Dann speichert die Prozedur die Werte der beiden Kombinationsfelder cboVersionID<\/b> und cboErrorCorrectionID <\/b>in entsprechenden Variablen, bevor sie darauf basierend ein Recordset öffnet. Dieses enthält den Datensatz der Tabelle tblNumberOfDataCodewords<\/b>, der den mit den Kombinationsfeldern ausgewählten Parametern entspricht. Aus dieser Tabelle entnehmen wir einige Werte und speichern diese in weiteren Variablen:<\/p>\n Nun folgt der interessante, in diesem Teil der Beitragsreihe beschriebene Part: Die Umwandlung des binären Codes in einen sogenannten „interleaved“ Code und das Ermitteln und Hinzufügen des Fehlerkorrekturcodes.<\/p>\n Dies geschieht in folgenden Schritten:<\/p>\n Schauen wir uns nun an, wie diese Funktionen arbeiten.<\/p>\n Code weiter bearbeiten<\/b><\/p>\n Den Code aus dem Textfeld txtCodeInhalt <\/b>beziehungsweise der Variablen strCode <\/b>verwenden wir nun nicht einfach so als ersten Teil des QR-Codes. Stattdessen wird dieser erste Teil gegebenenfalls noch etwas durcheinandergewürfelt – allerdings nach fest vorgegebenen Regeln. Dies geschieht allerdings nur ab einer gewissen Länge des Codes beziehungsweise wenn die einzelnen achtstelligen Binärzahlen auf mehr als nur die erste Gruppe aufgeteilt werden – also wenn in der Tabelle tbl-NumberOfDataCodewords <\/b>in der Spalte für die aktuelle Konfiguration (aus Version und Fehlerkorrektur) auch ein Wert in den Spalten NumberOfBlocksInGroup2 <\/b>beziehungsweise NumberOfDataCodewordsInGroup2Blocks <\/b>vorliegen. Dies ist zum Beispiel der Fall, wenn Sie die Version 5 <\/b>(37 x 37 Pixel) und den Fehlerkorrekturgrad Q <\/b>wählen. Dieser Code hat insgesamt 62 Codewörter, wobei die erste Gruppe zwei Blocks mit je 15 Codewörtern enthält und die zweite Gruppe zwei Blocks mit je 16 Codewörtern. Die Prozedur InterleavedCode <\/b>aus Listing 2 erwartet drei Parameter:<\/p>\n <\/p>\n Listing 2: „Vermischen“ des Binärcodes für den Ausgangstext<\/span><\/b><\/p>\n Die hinteren vier Werte wurden von der aufrufenden Prozedur cmdAktualisieren <\/b>aus der Tabelle tblNumberOfDataCodewords <\/b>für die aktuelle Kombination aus Version und Fehlerkorrekturgrad ausgewählt.<\/p>\n Die Prozedur ruft zunächst eine weitere Routine auf, die eine wichtige Aufgabe beim Mischen der Codewörter erfüllt – sie erstellt nämlich ein Array, aus dem später die neue Reihenfolge für die Codewörter entnommen wird. Diese Prozedur heißt CodeWoerterMatrix <\/b>und erwartet die soeben ermittelten vier Werte für die gleichnamigen Parameter lngBlocksGruppe1<\/b>, lngWoerterGruppe1<\/b>, lngWoerterGruppe2 <\/b>und lngBlocksGruppe2<\/b> (s. Listing 3).<\/p>\n Listing 3: Hilfsfunktion zum vermischen der Codewörter<\/span><\/b><\/p>\n Wenn die zweite Gruppe aus der Tabelle tblNumberOfDataCodewords <\/b>mindestens einen Block enthält, ist der erste Teil der If…Then<\/b>-Bedingung der Prozedur CodeWoerterMatrix <\/b>erfüllt. Dieser Teil füllt nun beispielsweise die laufenden Nummern (im Falle von Version 5<\/b>, Fehlerkorrekturlevel Q <\/b>von 1 <\/b>bis 62<\/b>) in ein zweidimensionales Array namens intCodewoerterMatrix()<\/b>. Dieses wird zuvor mit der ReDim<\/b>-Anweisung mit dem Bereich 1<\/b> bis 2 + 2 <\/b>für die erste Dimension und dem Bereich 1 <\/b>bis 16 <\/b>für die zweite Dimension dimensioniert. Die Zahlen werden dann einfach wie folgt eingetragen – also in vier Zeilen und 16 Spalten wie in der folgenden schematischen Darstellung:<\/p>\n Zuvor wird das Array noch komplett mit Nullen gefüllt. Sollte die Tabelle tblNumberOfDataCodewords<\/b> keinen einzigen Block in der Zeile NumberOfBlocksInGroup2 <\/b>für die gewählte Konfiguration aus Version und Fehlerkorrekturgrad liefern, führt die Prozedur CodeWoerterMatrix <\/b>den zweiten Teil der If…Then<\/b>-Bedingung aus. In diesem Fall legt die Prozedur nur für die Elemente der ersten Gruppe die laufenden Nummern der Codewörter an. In unserem einfachen Beispiel von oben sieht dies so aus – also nur mit einer Zeile und 16 Spalten:<\/p>\n Das entsprechende Array intCodewoerterMatrix() <\/b>wird nun als Rückgabewertan die aufrufende Prozedur zurückgegeben. Diese speichert nun zunächst den Code aus dem Parameter strCode <\/b>in der Variablen strTemp<\/b>. Wenn die aktuelle Konfiguration Wörter in der zweiten Gruppe hergibt, werden die Anweisungen in der ersten If…Then<\/b>-Bedingung ausgeführt. Hier werden zwei For…Next<\/b>-Schleifen durchlaufen, die äußere über die Anzahl der Wörter der zweiten Gruppe (hier 16), die innere die Anzahl der Blocks der ersten Gruppe plus die der zweiten Gruppe (hier 2 + 2<\/b>). Sollte das Array intCodewoerterMatrix <\/b>für die Laufvariablen i <\/b>und j <\/b>einen Wert ungleich 0 <\/b>enthalten, beginnt die Prozedur mit dem Erstellen einer neuen Code-Zeichenkette in der Variablen strTempNeu<\/b>. Dabei wird jeweils der Teil bestehend aus acht Zeichen aus strTemp <\/b>eingelesen und an strTempNeu <\/b>angehängt, welcher der laufenden Nummer des Elements von intCodewoerterMatrix() <\/b>mit den Werten für i <\/b>und j <\/b>entspricht.<\/p>\n Das heißt, dass das Array nun nicht zunächst spalten- und dann zeilenweise durchlaufen wird (also 1, 2, 3 und so weiter), sondern erst zeilen- und dann spaltenweise. Die Reihenfolge der neu zusammengesetzten Elemente lautet also:<\/p>\n 1<\/b>, 16<\/b>, 31<\/b>, 47<\/b>, 2<\/b>, 17<\/b>, 32<\/b>, 48<\/b>, 3<\/b>, 18<\/b>, 33<\/b>, 49<\/b>, 4<\/b>, 19<\/b>, 34<\/b>, 50<\/b>, 5<\/b>, 20<\/b>, 35<\/b>, 51<\/b>, 6<\/b>, 21<\/b>, 36<\/b>, 52<\/b>, 7<\/b>, 22<\/b>, 37<\/b>, 53<\/b>, 8<\/b>, 23<\/b>, 38<\/b>, 54<\/b>, 9<\/b>, 24<\/b>, 39<\/b>, 55<\/b>, 10<\/b>, 25<\/b>, 40<\/b>, 56<\/b>, 11<\/b>, 26<\/b>, 41<\/b>, 57<\/b>, 12<\/b>, 27<\/b>, 42<\/b>, 58<\/b>, 13<\/b>, 28<\/b>, 43<\/b>, 59<\/b>, 14<\/b>, 29<\/b>, 44<\/b>, 60<\/b>, 15<\/b>, 30<\/b>, 45<\/b>, 61<\/b>, 46<\/b>, 62<\/b>.<\/p>\n Sprich: Der Ausdruck in strTempNeu <\/b>beginnt mit dem ersten Codewort aus strTemp<\/b>, dann folgt das 16. Codewort, dann das 31. und so weiter.<\/p>\n Sollte die zweite Gruppe keinen einzigen Block enthalten, durchläuft die Prozedur wiederum in zwei Schleifen die Werte des Arrays intCodewoerterMatrix()<\/b>. Wenn intCodewoerterMatrix <\/b>an dieser Stelle nur eine Zeile mit Daten enthält, ist strTempNeu <\/b>gleich der mit strCode <\/b>übergebenen Zeichenkette. Das Ergebnis wird dann als Ergebnis der Funktion InterleavedCode <\/b>an die aufrufende Routine zurückgeliefert.<\/p>\n Fehlerkorrekturcode ermitteln<\/b><\/p>\n Der Fehlerkorrekturcode wird nach einer recht komplizierten Vorgehensweise erstellt. Dafür benötigen wir zwei Polynome – eines für den zu verschlüsselnden Text und ein sogenanntes „generator polynomial“.<\/p>\n Das Polynom für den zu verschlüsselnden Text erzeugen wir auf Basis der oben ermittelten Codewörter.<\/p>\n Ausgangspunkt für die Erstellung des Fehlerkorrekturcodes ist die Funktion InterleavedErrorCode<\/b> aus Listing 4. Sie erwartet die gleichen Parameter wie die oben beschriebene Funktion InterleavedCode <\/b>– plus einen weiteren, nämlich intAnzahlFehlerkorrekturwoerter<\/b>. Dies ist ein weiterer Wert, der bereits in cmdAktualisieren_Click <\/b>für die aktuelle Konfiguration aus Version und Fehlerkorrekturgrad aus der Tabelle tblNumberOfDataCodewords <\/b>ermittelt wurde – und zwar aus dem Feld ECCodewordsPerBlock<\/b>. Dieser Wert gibt an, wie viele binäre Wörter aus acht Zeichen noch an die bereits ermittelte Zeichenkette angehängt werden müssen, um den Code für den QR-Code zu vervollständigen. Das Verhältnis der Anzahl der Fehlerkorrekturwörter zu den Codewörtern steigt mit wachsendem Fehlerkorrekturgrad.<\/p>\n Listing 4: Erstellen des Fehlerkorrekturcodes (Teil I)<\/span><\/b><\/p>\n Die Prozedur ermittelt zunächst über die Funktion FehlerwoerterMatrix <\/b>ein ähnliches Array wie zuvor die Funktion CodewoerterMatrix<\/b>. Diese liefert wieder die Grundlage für die später zu verwendende Reihenfolge für das Durchmischen des Fehlerkorrekturcodes, um den „interleaved“ Code zu erhalten. Das Ergebnis speichert die Prozedur in der Variablen intFehlerwoerterMatrix()<\/b>.<\/p>\n Die Funktion FehlerwoerterMatrix <\/b>finden Sie in Listing 5. Sie erwartet die Anzahl der Blöcke in Gruppe 1 und Grupp2 (lngBlocksGruppe1 <\/b>und lngBlocksGruppe2<\/b>) sowie die Anzahl der Fehlerkorrekturwörter (intAnzahlFehlerkorrekturwoerter<\/b>).<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2014_04\/pic_947_002.png\")
<\/p>\n\n
\n0100001101000000111011000001000111101100000100011110110000010001<\/p>\n\n
![\"Das](\"..\/fileadmin\/_temp_\/2014_04\/pic_947_003.png\")
<\/p>\nPrivate Sub <\/span>cmdAktualisieren_Click()\r\n Dim <\/span>strCode As String<\/span>\r\n Dim <\/span>lngBlocksGruppe1 As Long<\/span>\r\n Dim <\/span>lngWoerterGruppe1 As Long<\/span>\r\n Dim <\/span>lngBlocksGruppe2 As Long<\/span>\r\n Dim <\/span>lngWoerterGruppe2 As Long<\/span>\r\n Dim <\/span>lngVersionID As Long<\/span>\r\n Dim <\/span>lngErrorCorrectionLevelID As Long<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>intAnzahlFehlerkorrekturWoerter As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n strCode = strCode & GetModeIndicator\r\n strCode = strCode & GetCharacterCountIndicator\r\n strCode = strCode & Encode(Me!txtAusgangstext, Me!cboModeID)\r\n strCode = AddPadBytes(strCode, Me!cboVersionID, Me!cboErrorCorrectionID)\r\n Me!txtCodeInhalt = strCode\r\n lngVersionID = Me!cboVersionID\r\n lngErrorCorrectionLevelID = Me!cboErrorCorrectionID\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblNumberOfDataCodewords " _\r\n & "WHERE VersionID = \" & lngVersionID _\r\n & \" AND ErrorCorrectionLevelID = \" & lngErrorCorrectionLevelID)\r\n lngBlocksGruppe1 = rst!NumberOfBlocksInGroup1\r\n lngWoerterGruppe1 = rst!NumberOfDataCodewordsInGroup1Blocks\r\n lngBlocksGruppe2 = Nz(rst!NumberOfBlocksInGroup2, 0)\r\n lngWoerterGruppe2 = Nz(rst!NumberOfDataCodewordsInGroup2Blocks, 0)\r\n intAnzahlFehlerkorrekturWoerter = rst!ECCodewordsPerBlock\r\n Me!txtInterleavedCode = InterleavedCode(strCode, lngBlocksGruppe1, lngWoerterGruppe1, _\r\n lngBlocksGruppe2, lngWoerterGruppe2)\r\n Me!txtInterleavedErrorCorrectionCode = InterleavedErrorCode(strCode, lngBlocksGruppe1, _\r\n lngWoerterGruppe1, lngBlocksGruppe2, lngWoerterGruppe2, intAnzahlFehlerkorrekturWoerter)\r\n Me!txtQRCode = Me!txtInterleavedCode & Me!txtInterleavedErrorCorrectionCode\r\nEnd Sub<\/span><\/pre>\n\n
\n
Public Function <\/span>InterleavedCode(ByVal strCode As String<\/span>, lngBlocksGruppe1 As Long<\/span>, _\r\n lngWoerterGruppe1 As Long<\/span>, lngBlocksGruppe2 As Long<\/span>, lngWoerterGruppe2 As Long<\/span>)\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>j As Integer<\/span>\r\n Dim <\/span>strTempNeu As String<\/span>\r\n Dim <\/span>strTemp As String<\/span>\r\n Dim <\/span>intCodewoerterMatrix() As Integer<\/span>\r\n intCodewoerterMatrix = CodeWoerterMatrix(lngBlocksGruppe1, lngWoerterGruppe1, _\r\n lngWoerterGruppe2, lngBlocksGruppe2)\r\n strTemp = Trim<\/span>(strCode)\r\n If <\/span>lngWoerterGruppe2 <> 0 Then<\/span>\r\n For j = 1 To lngWoerterGruppe2\r\n For i = 1 To lngBlocksGruppe1 + lngBlocksGruppe2\r\n If <\/span>intCodewoerterMatrix(i, j) <> 0 Then<\/span>\r\n strTempNeu = strTempNeu + Mid$(strTemp, intCodewoerterMatrix(i, j) * 8 - 7, 8)\r\n End If<\/span>\r\n Next<\/span> i\r\n Next<\/span> j\r\n End If<\/span>\r\n If <\/span>lngWoerterGruppe2 = 0 Then<\/span>\r\n For j = 1 To lngWoerterGruppe1\r\n For i = 1 To lngBlocksGruppe1 + lngBlocksGruppe2\r\n If <\/span>intCodewoerterMatrix(i, j) <> 0 Then<\/span>\r\n strTempNeu = strTempNeu + Mid$(strTemp, intCodewoerterMatrix(i, j) * 8 - 7, 8)\r\n End If<\/span>\r\n Next<\/span> i\r\n Next<\/span> j\r\n End If<\/span>\r\n InterleavedCode = strTempNeu\r\nEnd Function<\/span><\/pre>\n\n
Public Function <\/span>CodeWoerterMatrix(lngBlocksGruppe1 As Long<\/span>, lngWoerterGruppe1 As Long<\/span>, _\r\n lngWoerterGruppe2 As Long<\/span>, lngBlocksGruppe2 As Long<\/span>, strDataCodewords() As Variant<\/span>)\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>j As Integer<\/span>\r\n Dim <\/span>intZaehler As Integer<\/span>\r\n If <\/span>lngWoerterGruppe2 <> 0 Then<\/span>\r\n ReDim strDataCodewords(1 To lngBlocksGruppe1 + lngBlocksGruppe2, 1 To lngWoerterGruppe2)\r\n For j = 1 To lngWoerterGruppe2\r\n For i = 1 To lngBlocksGruppe1 + lngBlocksGruppe2\r\n strDataCodewords(i, j) = 0\r\n Next<\/span> i\r\n Next<\/span> j\r\n intZaehler = 1\r\n For i = 1 To lngBlocksGruppe1\r\n For j = 1 To lngWoerterGruppe1\r\n strDataCodewords(i, j) = intZaehler\r\n intZaehler = intZaehler + 1\r\n Next<\/span> j\r\n Next<\/span> i\r\n For i = lngBlocksGruppe1 + 1 To lngBlocksGruppe1 + lngBlocksGruppe2\r\n For j = 1 To lngWoerterGruppe2\r\n strDataCodewords(i, j) = intZaehler\r\n intZaehler = intZaehler + 1\r\n Next<\/span> j\r\n Next<\/span> i\r\n Else<\/span>\r\n ReDim strDataCodewords(1 To lngBlocksGruppe1 + lngBlocksGruppe2, 1 To lngWoerterGruppe1)\r\n For j = 1 To lngWoerterGruppe1\r\n For i = 1 To lngBlocksGruppe1\r\n strDataCodewords(i, j) = 0\r\n Next<\/span> i\r\n Next<\/span> j\r\n intZaehler = 1\r\n For i = 1 To lngBlocksGruppe1\r\n For j = 1 To lngWoerterGruppe1\r\n strDataCodewords(i, j) = intZaehler\r\n intZaehler = intZaehler + 1\r\n Next<\/span> j\r\n Next<\/span> i\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 \r\n16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 0\r\n31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46\r\n47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62<\/pre>\n
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16<\/pre>\n
Public Function <\/span>InterleavedErrorCode(ByVal strCode As String<\/span>, lngBlocksGruppe1 As Long<\/span>, _\r\n lngWoerterGruppe1 As Long<\/span>, lngBlocksGruppe2 As Long<\/span>, lngWoerterGruppe2 As Long<\/span>, _\r\n intAnzahlFehlerkorrekturWoerter As Integer<\/span>)\r\n Dim <\/span>i As Integer<\/span>, j As Integer<\/span>, intStart As Integer<\/span>, intEnde As Integer<\/span>\r\n Dim <\/span>intMessagePolynomial() As Integer<\/span>, intAnzahlKoeffizientenMessage As Integer<\/span>, intBlock As Integer<\/span>\r\n Dim <\/span>strTemp As String<\/span>, strCodeTeil As String<\/span>, strTempInterleaved As String<\/span>\r\n Dim <\/span>intFehlerwoerterMatrix() As Variant<\/span>, intCodeTeil As Integer<\/span>\r\n intFehlerwoerterMatrix() = FehlerwoerterMatrix(lngBlocksGruppe1, lngBlocksGruppe2, _\r\n intAnzahlFehlerkorrekturWoerter)\r\n intStart = 1\r\n intEnde = lngWoerterGruppe1 * 8\r\n intBlock = 0\r\n Do\r\n intAnzahlKoeffizientenMessage = 1\r\n If <\/span>intBlock < lngBlocksGruppe1 Then<\/span>\r\n For i = intStart To intEnde Step 8\r\n strCodeTeil = Mid$(strCode, i, 8)\r\n intCodeTeil = BinaerZuDezimal(strCodeTeil)\r\n ReDim Preserve intMessagePolynomial(intAnzahlKoeffizientenMessage) As Integer<\/span>\r\n intMessagePolynomial(intAnzahlKoeffizientenMessage) = intCodeTeil\r\n intAnzahlKoeffizientenMessage = intAnzahlKoeffizientenMessage + 1\r\n Next<\/span> i\r\n intStart = intEnde + 1\r\n If <\/span>intBlock = lngBlocksGruppe1 - 1 Then<\/span>\r\n intEnde = intEnde + lngWoerterGruppe2 * 8\r\n Else<\/span>\r\n intEnde = intEnde + lngWoerterGruppe1 * 8\r\n End If<\/span>\r\n End If<\/span>\r\n If <\/span>intBlock >= lngBlocksGruppe1 Then<\/span>\r\n For i = intStart To intEnde Step 8\r\n strCodeTeil = Mid$(strCode, i, 8)\r\n intCodeTeil = BinaerZuDezimal(strCodeTeil)\r\n ReDim Preserve intMessagePolynomial(intAnzahlKoeffizientenMessage) As Integer<\/span>\r\n intMessagePolynomial(intAnzahlKoeffizientenMessage) = intCodeTeil\r\n intAnzahlKoeffizientenMessage = intAnzahlKoeffizientenMessage + 1\r\n Next<\/span> i\r\n intStart = intEnde + 1\r\n intEnde = intEnde + lngWoerterGruppe2 * 8\r\n End If<\/span>\r\n ...<\/pre>\nPublic Function <\/span>FehlerwoerterMatrix(lngBlocksGruppe1 As Long<\/span>, lngBlocksGruppe2 As Long<\/span>, _\r\n intAnzahlFehlerkorrekturWoerter As Integer<\/span>) As Integer<\/span>()\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>j As Integer<\/span>\r\n Dim <\/span>intTemp() As Integer<\/span>\r\n Dim <\/span>intZaehler