<\/p>\n
Wohin man schaut, überall findet man QR-Codes. Falls Sie es nicht wissen: Das sind diese Kästchen, die mit mehr oder weniger chaotisch angeordneten Pixeln daherkommen. QR steht für Quick Response und der QR-Code ist im Gegensatz zu den Strichcodes ein zweidimensionaler Code. Er wurde 1994 von der japanischen Firma Denso Wave entwickelt und genießt eine immer größere Verbreitung. Da man darin beliebige Texte unterbringen kann, sind die Anwendungszwecke vielfältig und reichen von der Kennzeichnung von Bauteilen bis hin zur Kodierung von URLS, Telefonnummern oder kompletten Visitenkarten.<\/b><\/p>\n
Und da heutzutage jedes bessere Smartphone mit einer Kamera ausgestattet ist und Apps einsetzen kann, die sich zum Auslesen von QR-Codes eignen, wollen wir nicht hintenanstehen und eine eigene Implementierung zum Erstellen und Drucken von QR-Codes liefern. Diese können Sie dann etwa zur Codierung von Bestellnummern auf Rechnungen et cetera nutzen.<\/p>\n
Obwohl der QR-Code von einem einzelnen Unternehmen entwickelt wurde, ist dieser lizenzfrei und kann frei verwendet werden.<\/p>\n
Grundsätzlich bildet der QR-Code einen Text im Binärformat ab, also als Folgen der Zeichen 0 <\/b>und 1<\/b>. Eine 0 <\/b>entspricht einer weißen Stelle im Code, eine 1 <\/b>einer schwarzen.<\/p>\n
Größe der Matrix<\/b><\/p>\n
Die Größe der Codes reicht von 21 x 21 bis 177 x 177 Pixeln. Die verschiedenen Größen werden mit einer Version versehen. 21 x 21 entspricht Version 1<\/b>, 25 x 25 Version 2 <\/b>und so weiter – bis hin zu 177 x 177 mit Version 40<\/b>. Die Seitenlänge der Matrix für den Code wächst also abhängig vom benötigten Platz in Viererschritten.<\/p>\n
Fehlerkorrektur<\/b><\/p>\n
Neben dem eigentlichen codierten Text enthält der QR-Code noch eine Fehlerkorrektur. Es kann vorkommen, dass Teile des Codes unlesbar sind – beispielsweise weil an einem Aufkleber ein Teil des Codes beschädigt wurde. Deshalb wird der Text redundant im Code untergebracht. Es gibt vier verschiedene Stufen der möglichen Fehlerkorrektur:<\/p>\n
Codierung<\/b><\/p>\n
Je nach den zu codierenden Daten können Sie eine unterschiedliche Codierung verwenden. Es gibt die folgenden vier Möglichkeiten:<\/p>\n
Für unsere Belange sind vor allem numerische und alphanumerische Zeichen interessant. Wenn Sie beispielsweise nur numerische Zeichen verwenden möchten, benötigen Sie dazu weniger Platz als etwa für alphanumerische Zeichen.<\/p>\n
Welche Codierung Sie verwenden, wird wiederum an geeigneter Stelle im QR-Code abgebildet, damit das Lesegerät den Code entsprechend interpretieren kann.<\/p>\n
QR-Code generieren<\/b><\/p>\n
Ein QR-Code besteht aus verschiedenen Elementen. Einige davon sind Markierungen, die notwendig sind, damit das Lesegerät die Position zum Einlesen bestimmen kann. Weitere liefern Informationen darüber, welche Codierung und welche Fehlerkorrektur verwendet wurde. Den restlichen Platz füllt der eigentliche codierte Text sowie weitere speziell definierte Pixel, um den verbleibenden Platz aufzufüllen.<\/p>\n
Allgemeiner Ablauf<\/b><\/p>\n
Die Erstellung eines QR-Codes erfolgt in den folgenden Schritten:<\/p>\n
Vereinfachte Variante<\/b><\/p>\n
Wir werden in diesem Beitrag einfache QR-Codes erstellen und gegebenenfalls das eine oder andere Feature auslassen.<\/p>\n
Tabellen der Anwendung<\/b><\/p>\n
Um dem Charakter einer Access-Anwendung als Datenbank gerecht zu werden, speichern wir einige für die Konfiguration notwendigen Daten in Tabellen. Die erste Tabelle heißt tblVersions <\/b>und enthält die vier Versionen. Neben dem Primärschlüsselfeld liefert es noch die beiden Felder Version<\/b>, die den Kennbuchstaben für diese Version aufnehmen, sowie das Feld VersionWidth<\/b>, das die Kantenlänge für den QR-Code dieser Version speichert (siehe Bild 1).<\/p>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2014_02\/pic_932_001.png\")
<\/p>\n
Bild 1: Entwurf der Tabelle tblVersions<\/span><\/b><\/p>\n In Bild 2 finden Sie die Tabelle tblVersions <\/b>mit den enthaltenen Daten. Diese enthält alle 40 vorgesehenen Versionen.<\/p>\n Bild 2: Die Tabelle tblVersions mit den benötigten Datensätzen<\/span><\/b><\/p>\n Die nächste Tabelle heißt ErrorCorrectionLevels <\/b>und enthält die Felder ErrorCorrectionLevelID <\/b>als Primärschlüsselfeld, ErrorCorrectionLevel <\/b>mit dem entsprechenden Buchstaben (also L<\/b>, M<\/b>, Q <\/b>oder H<\/b>) und das Feld ErrorCorrectionPercent<\/b> mit dem ausgleichbaren Fehler in Prozent (siehe Bild 3).<\/p>\n Bild 3: Entwurf der Tabelle tblErrorCorrectionLevels<\/span><\/b><\/p>\n Bild 4 zeigt die Tabelle tblErrorCorrectionLevels <\/b>mit den vier verfügbaren Werten.<\/p>\n Bild 4: Die Tabelle tblErrorCorrectionLevels mit ihren Werten<\/span><\/b><\/p>\n Die Tabelle tblCharacterCapacities <\/b>führt die bisherigen Tabellen zusammen und liefert für jede dieser Tabellen die Kapazität für die vier Kodierungsarten Numerisch<\/b>, Alphanumerisch<\/b>, Binär <\/b>und Kanji<\/b>. Der Entwurf dieser Tabelle sieht wie in Bild 5 aus.<\/p>\n Bild 5: Entwurf der Tabelle tblCharacterCapacities<\/span><\/b><\/p>\n Die Tabelle enthält die Felder CharacterCapacity <\/b>als Primärschlüsselfeld, VersionID <\/b>als Fremdschlüsselfeld zur Tabelle tblVersions <\/b>und ErrorCorrectionLevelID <\/b>als Fremdschlüsselfeld zur Tabelle tblErrorCorrectionLevel<\/b>. Außerdem finden Sie hier die vier Felder CharactersNumericMode<\/b>, CharactersAlphanumericMode<\/b>, CharactersByteMode <\/b>und CharactersKanjiMode<\/b>. Diese nehmen die Anzahl der verfügbaren Zeichen für die entsprechende Konstellation auf.<\/p>\n Auch die Werte dieser Tabelle haben wir der Datenbank hinzugefügt. Bild 6 zeigt einen Ausschnitt der zur Verfügung stehenden Kombinationen.<\/p>\n Bild 6: Inhalt der Tabelle tblCharacterCapacities<\/span><\/b><\/p>\n Nun habe ich diese Form der Tabelle gewählt, da sich so die Daten aus der entsprechenden Tabelle unter http:\/\/www.thonky.com\/qr-code-tutorial\/character-capacities\/ <\/b>leicht hineinkopieren lassen. In der Tat ist für unsere Zwecke jedoch eine weitere Normalisierung dieser Tabele sinnvoll. So erstellen wir eine weitere Tabelle namens tblModes<\/b>, welche die drei Felder ModeID<\/b>, Mode <\/b>und ModeIndicator <\/b>enthält. Mode <\/b>enthält eine Bezeichnung, ModeIndicator <\/b>wird später erläutert.<\/p>\n Dieser fügen wir vier Datensätze mit den Werten aus Bild 7 hinzu.<\/p>\n Bild 7: Inhalt der Tabelle tblModes<\/span><\/b><\/p>\n Dadurch müssen wir die Tabelle tblCharacterCapabilities <\/b>ebenfalls anpassen beziehungsweise neu erstellen. Dazu ändern wir den Namen dieser Tabelle in tblCharacterCapacities_Alt<\/b>. Die neue Tabelle sieht im Entwurf wie in Bild 8 aus. Sie enthält nicht mehr den Wert für die zulässigen Zeichen für die vier verschiedenen Modes, sondern erlaubt die Kombination aus Version<\/b>, ErrorCorrectionLevel <\/b>und Mode<\/b>, um die dieser Kombination entsprechende CharacterCapability <\/b>in das gleichnamige Feld einzutragen.<\/p>\n Bild 8: Neuer Entwurf der Tabelle tblCharacterCapabilities<\/span><\/b><\/p>\n Nun benötigen wir noch eine kleine Routine, welche die Daten aus der alten in die neue Tabelle überträgt. Diese sieht wie in Listing 1 aus und durchläuft alle Datensätze der Tabelle tblCharacterCapacities_Alt<\/b>.<\/p>\n Listing 1: Umwandeln der Daten der Tabelle tblCharacterCapacities_Alt zu tblCharacterCapacities<\/span><\/b><\/p>\n Dabei legt sie für jeden der Datensätze vier neue in der Tabelle tblCharacterCapacities <\/b>an – je einen für jeden Mode<\/b>.<\/p>\n Der Mode landet in Form des entsprechenden Primärschlüsselwertes der Tabelle tblModes <\/b>im Fremdschlüsselfeld ModeID<\/b>, der ehemalige Wert der Felder CharactersNumericMode<\/b>, CharactersAlphanumericMode <\/b>et cetera landen im Feld CharacterCapacity<\/b>. Das Ergebnis sieht schließlich wie in Bild 9 aus. Hier können wir nun durch Filtern nach den entsprechenden Parametern die richtige optimale Version für die benötigte Anzahl Zeichen, den Fehlerkorrektur-Grad und den Mode auswählen.<\/p>\n Bild 9: Alle Kombinationen aus Version, ErrorCorrectionLevel und Mode samt CharacterCapacity in einer Tabelle<\/span><\/b><\/p>\n Formular zum Ermitteln der richtigen Version<\/b><\/p>\n Dazu bereiten wir ein kleines Formular vor, das im Entwurf wie in Bild 10 aussieht.<\/p>\n <\/p>\n Bild 10: Formular zur Eingabe von Text, Mode, Fehlerkorrektur und Version<\/span><\/b><\/p>\n Das Formular ist an die Tabelle tblQRCodes <\/b>aus Bild 11 gebunden, das soweit alle notwendigen Informationen aufnimmt. Neben dem zu codierenden Text sind das zunächst der Modus, der Grad der Fehlerkorrektur sowie die darauf basierende Version des QR-Codes.<\/p>\n Bild 11: Tabelle zum Speichern der QR-Code-Informationen<\/span><\/b><\/p>\n Um die richtige Version zu ermitteln, muss der Benutzer zunächst den zu codierenden Text in das Textfeld txtAusgangstext <\/b>eingeben. Aus diesem ermittelt das Formular später die Anzahl der zu codierenden Zeichen. Außerdem ist die Auswahl des Modus mit dem Kombinationsfeld cboModeID <\/b>und die Auswahl des Grades der Fehlerkorrektur mit dem Kombinationsfeld cboErrorCorrectionLevelID <\/b>nötig.<\/p>\n Die Aktualisierung aller drei Steuerelemente löst jeweils das Ereignis Nach Aktualisierung <\/b>und somit eine entsprechende Ereignisprozedur aus. Diese enthalten allesamt den Aufruf einer weiteren Prozedur namens VersionAktualisieren<\/b>. Diese Prozedur sorgt dafür, dass das Kombinationsfeld cboVersionID <\/b>nur die möglichen Einträge anzeigt, wobei die Zeichenanzahl des zu codierenden Textes, der gewählte Modus sowie die gewählte Fehlerkorrektur berücksichtigt werden. Die Werte des Kombinationsfeldes cboVersionID<\/b> sehen danach etwa wie in Bild 12 aus.<\/p>\n Bild 12: Formular zur Auswahl der Parameter<\/span><\/b><\/p>\n Die Prozedur VersionAktualisieren <\/b>finden Sie in Listing 2. Die Prozedur prüft zunächst, ob alle drei relevanten Steuerelemente Daten enthalten. Ist dies der Fall, stellt die Prozedur in der Variablen strWhere <\/b>das Where<\/b>-Kriterium für die Ermittlung der passenden Datensätze der Tabelle tblCharacterCapacity <\/b>zusammen.<\/p>\n Listing 2: Ermitteln aller möglichen Versionen aus der Tabelle tblVersions<\/span><\/b><\/p>\n Ist dies geschehen, stellt eine weitere Anweisung eine SQL-Abfrage zusammen, die alle Datensätze der Tabelle tblVersions <\/b>liefert, deren Feld Ver-sion-ID <\/b>in der Tabelle tblCharacterCapacities <\/b>enthalten ist und die zu der zuvor formulierten Where<\/b>-Bedingung passen.<\/p>\n Diesen SQL-Ausdruck weist die Prozedur schließlich dem Kombinationsfeld cboVersionID <\/b>zu und stellt den ersten Eintrag als Wert des Kombinationsfeldes ein. Dieser Wert ist gleichzeitig der für die kleinstmögliche Kantenbreite des QR-Codes.<\/p>\n Datenanalyse<\/b><\/p>\n Die erste Vereinfachung betreiben wir bei der Datenanalyse. Wir gehen der Einfachheit halber davon aus, dass der zu codierende Text aus den Zeichen laut ISO-8859-1 besteht, das heißt, wir verwenden den sogenannten Byte-Modus.<\/p>\n Die numerische Variante umfasst nur die Zahlen von 0 bis 9, die alphanumerische zusätzlich große Buchstaben von A bis Z sowie das Dollar-Zeichen ($), das Prozentzeichen (%), das Sternchen (*), das Plus (+), das Minus (-), den Punkt (.), den Schrägstrich (\/), den Doppelpunkt (:) und das Leerzeichen.<\/p>\n Codierung der Daten<\/b><\/p>\n Im ersten Schritt wählen Sie die gewünschte Fehlerkorrektur, was Sie ja mit dem Kombinationsfeld cboErrorCorrectionLevelID <\/b>bereits erledigt haben.<\/p>\n Der Einfachheit halber begnügen wir uns zunächst mit der einfachsten Fehlerkorrektur, bei welcher der QR-Code bei bis zu 7% schadhaften Bytes noch den Inhalt rekonstruieren kann. Der entsprechende Fehlerkorrekturgrad heißt L <\/b>(es gibt ja außerdem noch M<\/b>, Q <\/b>und H<\/b>).<\/p>\n Größe der Matrix bestimmen<\/b><\/p>\n Danach ermitteln wir die Größe der Matrix. Wie bereits erwähnt, gibt es 40 Varianten von 21 x 21 bis 177 x 177 Pixel. Welche davon aber ist die richtige Die zu verwendende Größe der Matrix und somit die Version des QR-Codes können Sie wie oben beschrieben im Formular frmQRCodes <\/b>ermitteln, und zwar durch Eingabe des zu codierenden Textes und der Auswahl von Fehlerkorrekturgrad und Zeichensatz.<\/p>\n Das erste Element: Der Mode-Indikator<\/b><\/p>\n Nun kommen wir endlich zum ersten Teil der codierten Zeichenkette, die wir später im QR-Code anzeigen wollen. Dabei handelt es sich um den Inhalt des Feldes CodeIndicator <\/b>für den gewählten Code. In unserem Fall ist das beispielsweise der Wert 0100 <\/b>für den Mode Alphanumeric<\/b>. Um diesen ersten Schritt zur Erstellung des Codes entsprechend zu würdigen, wollen wir dem Formular eine Schaltfläche namens cmdAktualisieren <\/b>hinzufügen. Diese soll beim Anklicken eine Prozedur auslösen, die den aktuellen Code zusammenstellt und im Textfeld txtQRCode <\/b>abbildet.<\/p>\n Diese Prozedur sieht aktuell wie in Listing 3 aus. Da abzusehen ist, dass die Prozedur auf diese Weise sehr lang und übersichtlich werden wird, quartieren wir die für den ersten Teil nötigen Anweisungen direkt in eine eigene Funktion aus:<\/p>\n Listing 3: Zusammenstellen des QR-Codes, erster Schritt<\/span><\/b><\/p>\n In der Prozedur cmdAktualisieren_Click <\/b>fügen wir die durch die einzelnen Funktionen gelieferten Zeichenketten dann etwa so zusammen:<\/p>\n Character Count Indicator<\/b><\/p>\n Das zweite Element im QR-Code ist ein Hinweis auf die Anzahl der codierten Zeichen. Dieser wird gleich hinter dem Mode-Indikator in die Zeichenfolge für den QR-Code eingefügt. Der Character Code Indicator <\/b>wird wiederum abhängig von zwei weiteren Parametern ermittelt – von der Version (also der Kantenlänge) und vom Zeichensatz.<\/p>\n Welcher Wert wann verwendet wird, haben wir in einer weiteren Tabelle gespeichert. Diese heißt tblCharacterCodeIndicators <\/b>und sieht im gefüllten Zustand im Datenblatt wie in Bild 13 aus. Unsere Prozedur, die durch einen Klick auf die Schaltfläche cmdAktualisieren <\/b>ausgelöst wird, erweitern wir also zunächst um den Aufruf der Prozedur, die den Character Count Indicator<\/b> liefert:<\/p>\n Bild 13: Der Character Count Inidcator<\/span><\/b><\/p>\n Diese Funktion sieht wie in Listing 4 aus. Die Prozedur ermittelt zunächst den CharacterCountIndicator <\/b>entsprechend den Werten für die Felder VersionID <\/b>und ModeID <\/b>aus der Tabelle tblCharacterCountIndicator<\/b>. Die Anzahl der zu codierenden Zeichen wird mit der Len<\/b>-Funktion ermittelt und in die Variable lngAnzahlzeichen <\/b>geschrieben. Daraus ermittelt die Routine mithilfe der Funktion Binaerzahl <\/b>die entsprechende Binärzahl (beim Wert 10 <\/b>etwa 1010). Die Variable intFehlendeNullen <\/b>wird mit der Differenz der Gesamtanzahl der geforderten Zeichen wie in intCharacterCountIndicator <\/b>gespeichert und der Länge des in strTemp <\/b>gespeicherten Ausdrucks (zum Beispiel 1010<\/b>) gefüllt. Die String<\/b>-Funktion erstellt dann eine Zeichenfolge, die aus der entsprechenden Anzahl des Zeichens 0 <\/b>besteht, um diese vorn an die als Binärzahl dargestellte Anzahl der Zeichen anzuhängen. Das Ergebnis ist schließlich auch der Rückgabewert der Funktion.<\/p>\n Listing 4: Funktion zum Ermitteln des Character Count Indicators<\/span><\/b><\/p>\n Binärzahl ermitteln<\/b><\/p>\n Um aus einer Dezimalzahl eine Binärzahl zu ermitteln und eine entsprechende Zeichenkette zurückzuliefern, verwenden wir die Funktion aus Listing 5. Diese Funktion ruft sich selbst rekursiv auf. Wenn Sie die Funktion etwa für die Zahl 10 <\/b>aufrufen, erhalten Sie den Wert 1010<\/b>.<\/p>\n Listing 5: Funktion zum Ermitteln von Binärzahlen als Zeichenkette<\/span><\/b><\/p>\n Binärzahl auffüllen<\/b><\/p>\n In dieser Lösung taucht oft die Anforderung auf, eine Binärzahl mit einer bestimmten Anzahl Stellen zu liefern. Dies bedeutet, dass eine Zahl wie 1101<\/b>, die mit acht Stellen geliefert werden soll, mit vier führenden Nullen aufgefüllt werden soll, also als 00001101<\/b>.<\/p>\n Dies erledigt die Funktion aus Listing 6. Die Funktion erwartet zwei Parameter: Die Zeichenkette mit der aufzufüllenden Binärzahl sowie die Anzahl der Stellen, welche die Zahl insgesamt einnehmen soll. Die Funktion ermittelt zunächst die tatsächlich vorhandene Anzahl Stellen und speichert diese in der Variablen intAnzahl<\/b>. Sollte der mit dem Parameter intStellen <\/b>gelieferte Wert größer als die Anzahl der vorhandenen Stellen sein, führt die Funktion den ersten Teil der folgenden If…Then<\/b>-Bedingung aus. Hier stellt die VBA-Funktion String <\/b>eine Zeichenkette zusammen, die aus der geforderten Anzahl Nullen besteht und hängt diese vorn an die aufzufüllende Binärzahl an.<\/p>\n Listing 6: Auffüllen einer Binärzahl mit führenden Nullen<\/span><\/b><\/p>\n In allen anderen Fällen, also wenn die Zahl etwa bereits mehr Stellen als gefordert aufweist, gibt die Funktion einfach die eingegebene Binärzahl zurück.<\/p>\n Kodieren des Textes<\/b><\/p>\n Zum Kodieren des im QR-Code anzuzeigenden Textes verwenden wir eine Startfunktion, die prüft, welche Codierung verwendet werden soll. Diese heißt schlicht Encode <\/b>und erwartet zwei Parameter: den zu codierenden Text und den Mode, den der Benutzer mit dem Kombinationsfeld cboModeID <\/b>ausgewählt hat (s. Listing 7).<\/p>\n Listing 7: Funktion, welche die eigentliche Funktion zum Codieren des Textes auswählt<\/span><\/b><\/p>\n Diese Funktion ruft, je nach dem gewählten Mode, eine von drei Funktionen auf – nämlich EncodeNumeric<\/b>, EncodeAlphanumeric <\/b>oder EncodeByte<\/b>.<\/p>\n Numerische Texte codieren<\/b><\/p>\n Die erste Funktion heißt EncodeNumeric<\/b> und sieht wie in Listing 8 aus. Die Funktion erwartet als Parameter lediglich den zu codierenden Text und gibt das Ergebnis als String zurück. Sie durchläuft eine Do While<\/b>-Schleife so lange, wie die Länge der in strText <\/b>gespeicherten Zeichenkette größer als 0 <\/b>ist.<\/p>\n Listing 8: Funktion zum Codieren numerischer Texte<\/span><\/b><\/p>\n Innerhalb der Funktion geschehen drei Dinge: Die linken drei Zeichen aus strText <\/b>landen in der Variablen strTemp<\/b> (wenn strText <\/b>nur noch ein oder zwei Zeichen enthält, landen nur diese in strTemp<\/b>). Die nun in strTemp <\/b>enthaltene Zahl wird mit der Funktion Binaer-zahl <\/b>in eine Binärzahl umgewandelt und an die Zeichenkette strEncoded <\/b>angehängt.<\/p>\n Von der Zeichenkette strText <\/b>werden nun so viele Zeichen vorn abgeschnitten, wie sich in der Variablen strTemp <\/b>befinden. Der Rest landet wieder in der Variablen strText<\/b>. Wenn die Schleife alle Zahlen in Dreierpacks in Binärzahlen umgewandelt hat, gibt die Funktion den Ausdruck aus strEncoded <\/b>als Ergebnis an die aufrufende Routine zurück.<\/p>\n Alphanumerische Texte codieren<\/b><\/p>\n Die zweite Funktion EncodeAlphanumeric<\/b> ist etwas aufwendiger (s. Listing 9). Sie erwartet ebenfalls den zu codierenden Text als String <\/b>und liefert das Ergebnis als eben solchen zurück. Alphanumerische Texte dürfen nur aus den Buchstaben von A <\/b>bis Z<\/b>, den Zahlen von 0 <\/b>bis 9 <\/b>und einer kleinen Auswahl von Sonderzeichen bestehen (die kleinen Buchstaben a <\/b>bis z <\/b>werden wie die entsprechenden großen Buchstaben behandelt).<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2014_02\/pic_932_004.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2014_02\/pic_932_002.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2014_02\/pic_932_005.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2014_02\/pic_932_003.png\")
<\/p>\n![\"Inhalt](\"..\/fileadmin\/_temp_\/2014_02\/pic_932_006.png\")
<\/p>\n![\"Inhalt](\"..\/fileadmin\/_temp_\/2014_02\/pic_932_008.png\")
<\/p>\n![\"Neuer](\"..\/fileadmin\/_temp_\/2014_02\/pic_932_009.png\")
<\/p>\nPublic Sub <\/span>TabelleUebertragen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>lngModeID As Long<\/span>\r\n Dim <\/span>intCharacterCapacity\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblCharacterCapacities_Alt\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n intCharacterCapacity = DLookup(\"CharactersNumericMode\", \"tblCharacterCapacities_Alt\", _\r\n \"CharacterCapacityID = \" & rst!CharacterCapacityID)\r\n lngModeID = DLookup(\"ModeID\", \"tblModes\", \"Mode=''Numeric''\")\r\n db.Execute \"INSERT INTO tblCharacterCapacities(VersionID, ErrorCorrectionLevelID, ModeID, " _\r\n & "CharacterCapacity) VALUES(\" & rst!VersionID & \", \" & rst!ErrorCorrectionLevelID _\r\n & \", \" & lngModeID & \", \" & intCharacterCapacity & \")\", dbFailOnError\r\n ''... übrige drei ModeIDs\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Alle](\"..\/fileadmin\/_temp_\/2014_02\/pic_932_010.png\")
<\/p>\n![\"Formular](\"..\/fileadmin\/_temp_\/2014_02\/pic_932_011.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2014_02\/pic_932_012.png\")
<\/p>\n![\"Formular](\"..\/fileadmin\/_temp_\/2014_02\/pic_932_013.png\")
<\/p>\nPrivate Sub <\/span>VersionAktualisieren()\r\n Dim <\/span>strWhere As String<\/span>\r\n If <\/span>Len<\/span>(Nz(Me!txtAusgangstext)) > 0 And Not<\/span> IsNull(Me!cboErrorCorrectionID) _\r\n And Not<\/span> IsNull(Me!cboModeID) Then<\/span>\r\n strWhere = strWhere & \"CharacterCapacity >= \" & Len<\/span>(Me!txtAusgangstext)\r\n strWhere = strWhere & \" AND ModeID = \" & Me!cboModeID\r\n strWhere = strWhere & \" AND ErrorCorrectionLevelID = \" & Me!cboErrorCorrectionID\r\n Me!cboVersionID.RowSource = \"SELECT tblVersions.VersionID, tblVersions.Version FROM tblVersions \" _\r\n \"WHERE tblVersions.VersionID IN (SELECT tblCharacterCapacities.VersionID " _\r\n & "FROM tblCharacterCapacities WHERE \" & strWhere & \")\"\r\n Me!cboVersionID = Me!cboVersionID.ItemData(0)\r\n Else<\/span>\r\n Me!cboVersionID.RowSource = \"SELECT VersionID, Version FROM tblVersions\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdAktualisieren_Click()\r\n Dim <\/span>strCode As String<\/span>\r\n Dim <\/span>strModeIndicator As String<\/span>\r\n strModeIndicator = DLookup(\"ModeIndicator\", \"tblModes\", \"ModeID = \" & Nz(Me!cboModeID))\r\n strCode = strCode & strModeIndicator\r\n ''...weitere Elemente\r\n Me!txtQRCode = strCode\r\nEnd Sub<\/span><\/pre>\nPrivate Function <\/span>GetModeIndicator()\r\n Dim <\/span>strTemp As String<\/span>\r\n strTemp = DLookup(\"ModeIndicator\", _\r\n \"tblModes\", \"ModeID = \" _\r\n & Nz(Me!cboModeID))\r\n GetModeIndicator = strTemp\r\nEnd Function<\/span><\/pre>\nPrivate Sub <\/span>cmdAktualisieren_Click()\r\n Dim <\/span>strCode As String<\/span>\r\n strCode = strCode & GetModeIndicator\r\n ''...weitere Teile\r\n Me!txtQRCode = strCode\r\nEnd Sub<\/span><\/pre>\n![\"Der](\"..\/fileadmin\/_temp_\/2014_02\/pic_932_014.png\")
<\/p>\nstrCode = strCode & GetCharacterCountIndicator<\/pre>\n
Private Function <\/span>GetCharacterCountIndicator()\r\n Dim <\/span>intCharacterCountIndicator As Integer<\/span>\r\n Dim <\/span>lngAnzahlZeichen As Long<\/span>\r\n Dim <\/span>intFehlendeNullen As Integer<\/span>\r\n Dim <\/span>strTemp As String<\/span>\r\n intCharacterCountIndicator = DLookup(\"CharacterCountIndicator\", _\r\n \"tblCharacterCountIndicators\", \"VersionID = \" & Me!cboVersionID _\r\n & \" AND ModeID = \" & Me!cboModeID)\r\n lngAnzahlZeichen = Len<\/span>(Nz(Me!txtAusgangstext))\r\n strTemp = Binaerzahl(lngAnzahlZeichen)\r\n intFehlendeNullen = intCharacterCountIndicator - Len<\/span>(strTemp)\r\n strTemp = String(intFehlendeNullen, \"0\") & strTemp\r\n GetCharacterCountIndicator = strTemp\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>Binaerzahl(lngZahl As Long<\/span>) As String<\/span>\r\n If <\/span>lngZahl > 0 Then<\/span>\r\n Binaerzahl = Binaerzahl(lngZahl \\ 2) & IIf(lngZahl Mod<\/span> 2, \"1\", \"0\")\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>BinaerzahlAuffuellen(strZahl As String<\/span>, intStellen As Integer<\/span>) _\r\n As String<\/span>\r\n Dim <\/span>intAnzahl As Integer<\/span>\r\n intAnzahl = Len<\/span>(strZahl)\r\n If <\/span>intStellen >= intAnzahl Then<\/span>\r\n BinaerzahlAuffuellen = String(intStellen - intAnzahl, \"0\") & strZahl\r\n Else<\/span>\r\n BinaerzahlAuffuellen = strZahl\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>Encode(strText As String<\/span>, lngModeID As Long<\/span>) As String<\/span>\r\n Select Case lngModeID\r\n Case <\/span>1\r\n Encode = EncodeNumeric(strText)\r\n Case <\/span>2\r\n Encode = EncodeAlphanumeric(strText)\r\n Case <\/span>3\r\n Encode = EncodeByte(strText)\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\nPrivate Function <\/span>EncodeNumeric(strText As String<\/span>) As String<\/span>\r\n Dim <\/span>strTemp As String<\/span>\r\n Dim <\/span>strEncoded As String<\/span>\r\n Do While<\/span> Len<\/span>(strText) > 0\r\n strTemp = Left<\/span>(strText, 3)\r\n strEncoded = strEncoded & Binaerzahl(CLng(strTemp))\r\n strText = Mid<\/span>(strText, Len<\/span>(strTemp) + 1)\r\n Loop<\/span>\r\n EncodeNumeric = strEncoded\r\nEnd Function<\/span><\/pre>\nPrivate Function <\/span>EncodeAlphanumeric(strText As String<\/span>) As String<\/span>\r\n Dim <\/span>strTemp As String<\/span>\r\n Dim <\/span>strZeichen As String<\/span>\r\n Dim <\/span>strEncoded As String<\/span>\r\n Dim <\/span>lngChar As Long<\/span>\r\n strZeichen = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-.\/:\"\r\n Do While<\/span> Len<\/span>(strText) > 0\r\n strTemp = Left<\/span>(strText, 2)\r\n Select Case Len<\/span>(strTemp)\r\n Case <\/span>1\r\n lngChar = InStr<\/span>(1, strZeichen, strTemp) - 1\r\n strEncoded = strEncoded _\r\n & BinaerzahlAuffuellen(Binaerzahl(lngChar), 6)\r\n Case <\/span>2\r\n lngChar = InStr<\/span>(1, strZeichen, Mid<\/span>(strTemp, 1, 1)) - 1\r\n lngChar = lngChar * 45 + _\r\n InStr<\/span>(1, strZeichen, Mid<\/span>(strTemp, 2, 1)) - 1\r\n strEncoded = strEncoded & _\r\n BinaerzahlAuffuellen(Binaerzahl(lngChar), 11)\r\n End Select<\/span>\r\n strText = Mid<\/span>(strText, Len<\/span>(strTemp) + 1)\r\n Loop<\/span>\r\n EncodeAlphanumeric = strEncoded\r\nEnd Function<\/span><\/pre>\n