Márgenes

Los códigos QR deben tener a su alrededor una zona lisa (de color homogéneo sin nada impreso) de al menos 4 veces el tamaño de un módulo, que permita a los lectores leer el código con mayor facilidad y distinguirlo de otros elementos cercanos. El color de esta zona también determina la reflectancia del código (oscuro sobre claro o claro sobre oscuro).

Patrones de detección de posición

Son patrones de 7x7 módulos separados del código por tiras de módulos blancos a su alrededor. Se colocan siempre en las esquinas superior izquierda, superior derecha e inferior izquierda.

La posición de estos tres patrones en las esquinas del código QR forma un triángulo isósceles, lo que permite al escáner reconocer el código QR incluso si está inclinado, girado, o si se lee desde cualquier dirección o en un espejo.

Patrones de alineación

Son patrones de 5x5 módulos. El número y posición de estos patrones depende de la versión. A medida que el tamaño del código QR aumenta, se añaden más en ubicaciones específicas para proporcionar estabilidad adicional. Para la versión de nuestro código QR se necesita 1 patrón en la fila y columna 23.

La función de estos módulos es proporcionar una referencia adicional a los escáneres para corregir pequeñas deformaciones o distorsiones por si el código está impreso en una superficie curva, se ha doblado, o si el lector no está perfectamente alineado. Aseguran que la cuadrícula del código se mantenga recta.

Patrones de temporización

Son patrones de módulos alternados (oscuro y claro) que se sitúan en la fila y columna 7 entre el patrón de posición de la esquina superior izquierda y los patrones de posición de la esquina superior derecha y esquina inferior izquierda.

Su función es ayudar al lector a determinar el tamaño o escala de los módulos y la dimensión del código QR. Ayuda a mantener la cuadrícula alineada correctamente tratando de mantener la uniformidad en la separación de los módulos, facilitando una lectura precisa.

Información sobre la versión

Estos módulos sólo aparecen a partir de la versión 7. Consiste en un patrón de 18 módulos que proporciona datos acerca de la versión específica del código QR que se está utilizando. En estas versiones tan grandes, sin la información de versión, un escáner podría tener dificultades para identificar el tamaño específico del código QR y para determinar cómo debe organizar los datos que extrae de él.

Independientemente de la versión del código que hemos generado nosotros, veamos como se calcula. Primero se codifica el número de la versión a binario (con seis bits, 2 = 000010). La información binaria de la versión se convierte en un patrón de 18 bits que contiene 6 bits de datos (la versión) y 12 bits de código de corrección de errores BCH (Bose-Chaudhuri-Hocquenghem). Para calcular estos 12 bits adicionales que se concatenarán a los bits de la versión seguimos este proceso:

1. Concatenamos doce ceros a los bits de la versión: 001001000000000000
2. Calculamos el resto de dividirlo por 1111100100101
1. Cogemos los 13 primeros bits
2. Si el primer bit es 0, le descartamos y bajamos el siguiente bit
3. Si el primer bit es 1, realizamos un XOR, descartamos el primer cero y bajamos el siguiente bit
4. Así hasta que no queden más bits que bajar
3. El resto que quede son los bits de corrección

Tenemos que los 18 bits nos quedan . Estos se colocan por duplicado en los módulos reservados para ello:

Información del formato

Consiste en un patrón de 15 módulos situado también junto a los patrones de posición. Sirve para identificar el nivel de corrección de errores elegido y el patrón de máscara usados en el código.

El nivel de corrección de errores ya lo hemos mencionado, y el patrón de máscara lo estudiaremos en profundidad más adelante. Por ahora nos basta con saber que existen un total de ocho, y que se codifican como se indica en la tabla de abajo.

Los 15 módulos se dividen en 5 módulos de datos y 10 módulos de corrección de errores. De los 5 módulos de datos, 2 de ellos se reservan para el nivel de corrección de errores, y los otros 3 son para identificar una de las ocho posibles máscaras que se pueden aplicar. Para calcular el color de los 15 módulos, es similar a como hicimos con la información de la versión. Primero codificamos el nivel de corrección de errores elegido y le concatenamos el código asociado a la máscara aplicada, según estas tablas:

En nuestro caso los bits de datos quedarían . Ahora tenemos que calcular los 10 bits de corrección de errores:

1. Concatenamos diez ceros a los bits de datos: 0000000000
2. Calculamos el resto de dividirlo por 10100110111
1. Cogemos los 11 primeros bits
2. Si el primer bit es 0, le descartamos y bajamos el siguiente bit
3. Si el primer bit es 1, realizamos un XOR, descartamos el primer cero y bajamos el siguiente bit
4. Así hasta que no queden más bits que bajar
3. El resto que quede son los bits de corrección

Tenemos que los 15 bits nos quedan .

Sin embargo, para asegurarse de que nunca serán todo ceros, se aplica un XOR con la máscara 101010000010010, de forma que el resultado final a colocar en el código QR es . Estos se colocan por duplicado en los módulos reservados para ello. Otro detalle a tener en cuenta, es que el módulo al final de la tira de módulos de abajo a la izquierda, es siempre de color oscuro. Porque así lo decidió el creador.

Módulos para datos

Para introducir nuestro mensaje, dirección URL, o lo que esa, en el código QR, primero lo tenemos que codificar, transformar a ceros y unos. La codificación dependerá del modo en el que se usa el código QR. Existen varios (aunque cuatro principales):

• Numérico (0001): sólo permite dígitos del 0 al 9. Es el más eficiente en términos de capacidad.
• Alfanumérico (0010): permite los dígitos del 0 al 9, las letras de la A a la Z (sólo mayúsculas) y algunos caracteres especiales.
• Binario (0100): permite los caracteres de la tabla de codificación ISO/IEC 8859-1 (el alfabeto español y otros caracteres). Cada uno de estos caracteres (una R, un 2, un punto, etc) se codifica con 8 módulos, es decir, un byte.
• Kanji (1000): diseñada para caracteres Kanji/Kana del idioma japonés.
• Otros modos: permiten mezclar los modos anteriores para optimizar el tamaño (dividiendo el mensaje en segmentos), usar caracteres de otros idiomas, dividir el código QR en otros más pequeños y luego leerlos por separado y ordenarlos, y más cosas.

El mensaje se analiza y se divide en segmentos que se codifican por separado en el modo más óptimo. En este caso, para simplificar la creación del código QR no optimizaré, y usaré sólamente un segmento para todo el mensaje en modo binario. El mensaje introducido, queda codificado tal que así:

Los diferentes segmentos codificados se concatenan en orden siguiendo una estructura, se añade al final del último unos bits de terminación y se rellena con bits adicionales hasta completar la capacidad máxima del código QR. El siguiente paso es dividir en bloques todo el churro de bits. Debemos dividirlo en diferentes bloques de distintos tamaños, que dependen de la versión y capacidad de corrección de errores elegida:

1. El modo del segmento
   • 4 módulos (en nuestro caso 0100 para el formato binario)
2. Número de caracteres del segmento
   • Para modo binario, 8 módulos de la versión 1 a la 9 y 16 módulos de la versión 10 en adelante
3. El segmento de nuestro mensaje codificado
4. Bits de terminación
   • Hasta 4 módulos blancos al final del último segmento.
   • Sólo se añaden si aún queda espacio.
   • Indican que los siguientes bits ya son de relleno.
5. Bits de relleno
   • Se repiten alternativamente los bytes 11101100 y 00010001 hasta que se alcanza la capacidad máxima de datos.

Módulos para corrección de errores

Cada bloque de datos, tiene asociado unos módulos de corrección de errores. Sin ellos, bastaría que se manchase el código, se deteriorara o se rompiera un cachito para perder lo que hay escrito en él.

Iré rápido en esta sección porque no es fácil de explicar y requiere muchos cálculos, matemáticas, teoría de códigos, división de polinomios, cuerpos de Galois, códigos Reed Solomon, etc. Es la parte que más me ha costado de implementar. Consiste básicamente en añadir redundancia a nuestro mensaje.

Dependiendo de la versión y de la capacidad de corrección de errores elegida, se requiere una cantidad diferente de módulos para la corrección de errores. Hay definidos hasta treinta y seis polinomios dependiendo de esta cantidad. Para obtener x cantidad de módulos de corrección se usa un polinomio, para otra cantidad se usa otro polinomio, y así, hasta treinta y seis posibilidades. Este polinomio se utiliza como divisor.

Por cada bloque de datos que hemos generado anteriormente, se calcula un bloque de corrección de errores. El proceso simplificado sería:

1. Se divide el bloque de datos en bytes (bloques de 8 módulos).
2. Cada byte representa el coeficiente de un polinomio.
3. Se multiplica este polinomio por el grado del polinomio del divisor.
4. Se realiza la división utilizando campos Galois.
5. El resto de la división, son los bits de corrección de errores.

Como es algo complejo de mostrar, porque ya digo que requiere estudiar primero, me salto mostrar un ejemplo.