El empleo de códigos de barras está ampliamente difundido en todos los rincones del mundo, dada su sencillez de representar información, y ser accedida a ella de fomra rápida.

En este artículo abordamos la creación de estos códigos empleando el estándar code128 y un programa en C++

 

 


 

 

 

 


¿Qué es el Code128?
  • El Code 128 es una simbología de muy alta densidad. Es empleado para la representación de caracteres alfanuméricos o sólo numéricos.
  • Éste estandar puede codificar todos los 128 caracteres de la tabla ASCII, entre otros estándares (incluso caracteres latinos).
  • Es empleado ampliamente alrededor del mundo para el rastreo de paquetes, controles de stock industriales, identificación de contenedores y pallets en la cadena de abastecimiento.
  • La simbología fue definida como ISO/IEC 15417:2007.

 

Especificaciones

Un código de barra Code 128 posee seis (6) secciones:

  1. Zona de silencio (Quiet Zone)
  2. Caracter de inicio
  3. Datos codificados
  4. Caracter de verificación (Checksum)
  5. Caracter de finalización (2)
  6. Zona de silencio (1)

 

Partes del Codigo 128 - Wikipedia

Secciones del Code128

 

 

Subtipos

Existen tres variantes para Code 128. Todos ellos en total incluyen 107 símbolos: 103 de datos, 3 caracteres de inicio y un único bit de parada.

Si bien todos comparten la simbología de barras, la forma de calcular cada uno de ellos es diferente.

  • 128A (Set de códigos A) - Caracteres ASCII 00 al 95 (0-9, A-Z y códigos de control), caracteres especiales y FNC 1-4
  • 128B (Set de códigos B) - Caracteres ASCII 32 al 127 (0-9, A-Z, a-z), caracteres especiales y FNC 1-4
  • 128C (Set de códigos C) - 00-99 (Codifica cada dos dígitos en un único código) y FNC1

Por razones de compatibilidad y utilidad, en este artículo emplearemos el 128B, ya que nos permite crear códigos alfanuméricos con mayúsculas y minúsculas.

 

Tabla ASCII

Antes de comenzar, es necesario saber la correspondencia que tiene el sistema Code128 con los valores ASCII de cada caracter. A continuación la tabla:

Code 128
Valor128A128B128CCódigo ASCII
CaracterBar/Space PatternBar/Space Weights
0 space space 00 0032 or 0212 Space or Ô 11011001100 212222
1 ! ! 01 33 ! 11001101100 222122
2 " " 02 34 " 11001100110 222221
3 # # 03 35 # 10010011000 121223
4 $ $ 04 36 $ 10010001100 121322
5 % % 05 37 % 10001001100 131222
6 & & 06 38 & 10011001000 122213
7 ' ' 07 39 ' 10011000100 122312
8 ( ( 08 40 ( 10001100100 132212
9 ) ) 09 41 ) 11001001000 221213
10 * * 10 42 * 11001000100 221312
11 + + 11 43 + 11000100100 231212
12 , , 12 44 , 10110011100 112232
13 - - 13 45 - 10011011100 122132
14 . . 14 46 . 10011001110 122231
15 / / 15 47 / 10111001100 113222
16 0 0 16 48 0 10011101100 123122
17 1 1 17 49 1 10011100110 123221
18 2 2 18 50 2 11001110010 223211
19 3 3 19 51 3 11001011100 221132
20 4 4 20 52 4 11001001110 221231
21 5 5 21 53 5 11011100100 213212
22 6 6 22 54 6 11001110100 223112
23 7 7 23 55 7 11101101110 312131
24 8 8 24 56 8 11101001100 311222
25 9 9 25 57 9 11100101100 321122
26 : : 26 58 : 11100100110 321221
27 ; ; 27 59 ; 11101100100 312212
28 < < 28 60 < 11100110100 322112
29 = = 29 61 = 11100110010 322211
30 > > 30 62 > 11011011000 212123
31 ? ? 31 63 ? 11011000110 212321
32 @ @ 32 64 @ 11000110110 232121
33 A A 33 65 A 10100011000 111323
34 B B 34 66 B 10001011000 131123
35 C C 35 67 C 10001000110 131321
36 D D 36 68 D 10110001000 112313
37 E E 37 69 E 10001101000 132113
38 F F 38 70 F 10001100010 132311
39 G G 39 71 G 11010001000 211313
40 H H 40 72 H 11000101000 231113
41 I I 41 73 I 11000100010 231311
42 J J 42 74 J 10110111000 112133
43 K K 43 75 K 10110001110 112331
44 L L 44 76 L 10001101110 132131
45 M M 45 77 M 10111011000 113123
46 N N 46 78 N 10111000110 113321
47 O O 47 79 O 10001110110 133121
48 P P 48 80 P 11101110110 313121
49 Q Q 49 81 Q 11010001110 211331
50 R R 50 82 R 11000101110 231131
51 S S 51 83 S 11011101000 213113
52 T T 52 84 T 11011100010 213311
53 U U 53 85 U 11011101110 213131
54 V V 54 86 V 11101011000 311123
55 W W 55 87 W 11101000110 311321
56 X X 56 88 X 11100010110 331121
57 Y Y 57 89 Y 11101101000 312113
58 Z Z 58 90 Z 11101100010 312311
59 [ [ 59 91 [ 11100011010 332111
60 \ \ 60 92 \ 11101111010 314111
61 ] ] 61 93 ] 11001000010 221411
62 ^ ^ 62 94 ^ 11110001010 431111
63 _ _ 63 95 _ 10100110000 111224
64 NUL ` 64 96 ` 10100001100 111422
65 SOH a 65 97 a 10010110000 121124
66 STX b 66 98 b 10010000110 121421
67 ETX c 67 99 c 10000101100 141122
68 EOT d 68 100 d 10000100110 141221
69 ENQ e 69 101 e 10110010000 112214
70 ACK f 70 102 f 10110000100 112412
71 BEL g 71 103 g 10011010000 122114
72 BS h 72 104 h 10011000010 122411
73 HT i 73 105 i 10000110100 142112
74 LF j 74 106 j 10000110010 142211
75 VT k 75 107 k 11000010010 241211
76 FF l 76 108 l 11001010000 221114
77 CR m 77 109 m 11110111010 413111
78 SO n 78 110 n 11000010100 241112
79 SI o 79 111 o 10001111010 134111
80 DLE p 80 112 p 10100111100 111242
81 DC1 q 81 113 q 10010111100 121142
82 DC2 r 82 114 r 10010011110 121241
83 DC3 s 83 115 s 10111100100 114212
84 DC4 t 84 116 t 10011110100 124112
85 NAK u 85 117 u 10011110010 124211
86 SYN v 86 118 v 11110100100 411212
87 ETB w 87 119 w 11110010100 421112
88 CAN x 88 120 x 11110010010 421211
89 EM y 89 121 y 11011011110 212141
90 SUB z 90 122 z 11011110110 214121
91 ESC { 91 123 { 11110110110 412121
92 FS | 92 124 | 10101111000 111143
93 GS } 93 125 } 10100011110 111341
94 RS ~ 94 126 ~ 10001011110 131141
95 US DEL 95 200 È 10111101000 114113
96 FNC 3 FNC 3 96 201 É 10111100010 114311
97 FNC 2 FNC 2 97 202 Ê 11110101000 411113
98 Shift B Shift A 98 203 Ë 11110100010 411311
99 Code C Code C 99 204 Ì 10111011110 113141
100 Code B FNC4 Code B 205 Í 10111101110 114131
101 FNC 4 Code A Code A 206 Î 11101011110 311141
102 FNC 1 FNC 1 FNC 1 207 Ï 11110101110 411131
103 Start Code A --- --- 208 Ð 11010000100 211412
104 Start Code B --- --- 209 Ñ 11010010000 211214
105 Start Code C --- --- 210 Ò 11010011100 211232
106 Stop (7 bars/spaces) --- --- 211 Ó 1100011101011 2331112
--- unused to prevent misreading --- --- --- --- --- 211133

 

 

Bits de arranque y de finalización

Los bits de arranque y de finalización son los que delimitan todo el código comprendido entre ellos.

Valor 128A 128B 128C ASCII Caracter Bar/Space Pattern Bar/Space Weights
103 Start Code A --- --- 208 Ð 11010000100 211412
104 Start Code B --- --- 209 Ñ 11010010000 211214
105 Start Code C --- --- 210 Ò 11010011100 211232
106 Stop (7 bars/spaces) --- --- 211 Ó 1100011101011 2331112

 

 

Calcular el bit de verificación

Básicamente el armado es de la siguiente forma:

[INICIO]DATOS[BIT][FIN]

Empleando la variante B, el caracter de inicio y de fin es Ñ y Ó respectivamente, o ASCII 209 y ASCII 211.

El bit de comprobación será el encargado de comprobar que la lectura se haya realizado en forma correcta. Para calcularlo se emplea el método de suma ponderada. Su suma tiene la siguiente forma:

Donde:

  • Sp es la suma ponderada que necesitamos obtener en primer lugar.
  • 104 corresponde al bit de inicio (en el formato Code128)
  • n corresponde al total de caracteres que se desean convertir.
  • ax corresponde al caracter en particular que se está convirtiendo (en su código ASCII).

 

 

Una vez obtenido el valor de la suma (Sp) se divide por 103, obteniendo como dato útil el resto

Donde:

  • Bitc : Bit de comprobación
  • Sp es la suma ponderada obtenida anteriormente.
  • MOD operador matemático para obtener el resto de la división.

 

 

Finalmente para buscar el caracter ASCII equivalente al Code128 procede de la siguiente forma:

 

Es decir, si Bitc es menor que 95, entonces se suma 32 para lograr una correspondencia exacta con el caracter ASCII que le corresponde. Si es mayor o igual que 95, entonces se suma 50 para evitar caer el rango no deseado comprendido entre los valores 127 y 199.

El valor obtenido es el bit de comprobación (Bitc).


 


 

Ejemplo

Los casos quedan mucho más claros con un ejemplo. Para ello he desarrollado el siguiente prototipo:

Codificaremos la palabra Binari-OS en code128, variante B. Para ello ya se ha visto que la forma básica del armado es el siguiente:

[INICIO]Binari-OS[Bit][FIN]

 

Los datos que ya se tienen son:

  • [INICIO] = Ñ ó ASCII 209
  • [FIN] = Ó ó ASCII 211
  • Binari-OS

 

Para hallar el único dato que queda, se debe comenzar obteniendo la correspondencia entre caracteres y su código ASCII:

 

A continuación se realiza la suma ponderada de todos los caracteres que tiene la cadena a codificar (Binari-OS) más el bit de inicio:

 

 

 

 

La suma de todos los caracteres correspondientes a Binari-OS = 2552. Luego éste valor se divide por 103 y obtenemos el resto.

2552 / 103 = 24 resto 80.


 

 

 

Finalmente, realizamos la última comprobación:  80 < 95, por lo que se debe sumar 32.

 

 

Es decir, el caracter de verificación corresponde al código ASCII 112, o más conocido como el caracter p.

 

Ahora estamos en condiciones de armar el código completo en ASCII:

ÑBinari-OSpÓ

 

Finalmente empleando una fuente como Code 128 quedará conformado el código:


 

Función en C++

Esta es una de las funciones más simples que se pueden encontrar en la red hechas para C++. La realicé para un proyecto particular.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
/*		Desarrollado por Cristian1604 en C++ para Binarios
			         http://binari-os.com.ar
	        Documentación y ejemplos de aplicación en
http://binari-os.com.ar/index.php/cs-computacion/122-generar-codigos-de-barra-con-el-estandar-code128 Marzo 2012 This email address is being protected from spambots. You need JavaScript enabled to view it. */     int Code128 (char cadena[]) { int pos = 1; int i = 1; int checksum = 104; //el caracter de verificacion siempre es 104 para la norma B char _inicio = 'Ñ'; char _final = 'Ó'; char aux[50] = {'\0'}; int char_a_int; char int_a_char;     if (cadena[0] == '\0') //verifica que haya entrado algún parámetro. De lo contrario devuelve 1 (error) return 1;   //copiar la cadena original a una auxiliar bit a bit do { aux[pos] = cadena[pos - 1]; pos++; } while (cadena[pos - 1] != '\0');     //En la cadena original insertamos el bit de inicio y reubicamos la cadena cadena[0] = _inicio; pos = 1; do { cadena[pos] = aux[pos]; pos++; } while (aux[pos] != '\0');     //ahora la variable 'pos' queda ubicada donde va el bit de paridad (checksum)   do { char_a_int = cadena[i]; checksum = checksum + ((char_a_int-32)*i); i++; } while (cadena[i] != '\0');   checksum = (checksum % 103); //103 vale para Code128. if (checksum < 95) checksum = checksum + 32; else checksum = checksum + 50;   int_a_char = checksum; //pasar el valor numérico al tipo caracter   cadena[pos] = int_a_char; pos++; cadena[pos] = _final; //agregar el bit de parada pos++; cadena[pos] = '\0'; //fin de la cadena   return 0; }

 

 

 

 

Caja de Herramientas

He subido un generador de código de barras, el mismo que he desarrollado en C++, pero además posee una interfaz para mostrar el resultado. Click aquí para descargar

 

Tipogradía code128.ttf  Click aquí para descargar

 

 

Links de interés

 

 


Licencia . Ver información de licencia & cómo copiar material de esta web aquí.  - Autor: Cristian1604 - Imágenes: Cristian1604. Ilustración inicio: Cristian1604

 

.