T.P. Nº: 2 - Códigos -

(1)

Escuela de Educación Técnica N° 17 Departamento de Electrónica D.E. 13 Región V

__________________________________________________________________________________________

T.P. Nº: 2 - Códigos - 1.- Exprear el decimal 153 en:

1.1) BCD Aiken 1.2) BCD Exceso 3 1.3) BCD Natural 1.4) Binario Natural 1.5) ASCII

1.6) EBCDIC

2.- Diseñar un código BCD con pesos 4,4,3,(-2) que sea autocomplementario.

3.- Obtener el equivalente binario, hexadecimal y decimal de los siguientes caracteres dados en código ASCII.

a) K b) % c) 8 d) a e) @ f) ó

4.- ¿Cuál es la representación en Gray (4 bits) de los binarios: 0110 y 1111?

5.- ¿Cuál es la representación en Binario (4 bits) de los números Gray: 0111 y 1101?

6.- Convertir el número: 0100 1001 1011 expresado en BCD Exceso 3 a:

6.1) BCDN 6.2) Decimal 6.3) Binario Natural 6.4) BCD Aiken

7.- A partir del BCD Exceso 3 generar un nuevo código con paridad par (even) que lo llamaremos "código E".

8.- A partir del BCD Aiken generar un nuevo código con paridad impar (odd) que lo llamaremos "código O".

9.- Se ha utilizado el código de Hamming descripto mas abajo para transmitir tres caracteres del código BCDN con el agregado de tres bits adicionales (de paridad par).

Si el mensaje recibido en cada caso es el que se indica, averiguar cuál fue el mensaje transmitido.

9.1) 1011100 9.2) 0100110 9.3) 0011000

I1 I2 I3 I4 P1 P2 P3 X X X X X X X X X X X X

10.- Se reciben consecutivamente las siguientes palabras en código ASCII. Indicar cual es el texto que debería imprimirse de acuerdo a ese mensaje.

01010100 10000010 01100011 01101110 01101001 01100011 01100001 01110011 11111111 01000100 01101001 01100111 01101001 01110100 01100001 01101100 01100101 01110011 00101110

(2)

Códigos

Decimal Binario* Gray BCD Nat. BCD Exc.3 BCD Aiken BCD Gray Johnson ASCII EBCDIC BCD 5421 BCD 4221

Nº 8 4 2 1 8 4 2 1 8 4 2 1 (a) 2 4 2 1 5 4 2 1 4 2 2 1

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0011 0000 1111 0000 0 0 0 0 0 0 0 0

1 0 0 0 1 0 0 0 1 0 0 0 1 0 1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 1 0011 0001 1111 0001 0 0 0 1 0 0 0 1

2 0 0 1 0 0 0 1 1 0 0 1 0 0 1 0 1 0 0 1 0 0 0 1 1 0 0 0 1 1 0011 0010 1111 0010 0 0 1 0 0 0 1 0 3 0 0 1 1 0 0 1 0 0 0 1 1 0 1 1 0 0 0 1 1 0 0 1 0 0 0 1 1 1 0011 0011 1111 0011 0 0 1 1 0 0 1 1 4 0 1 0 0 0 1 1 0 0 1 0 0 0 1 1 1 0 1 0 0 0 1 1 0 0 1 1 1 1 0011 0100 1111 0100 0 1 0 0 1 0 0 0 5 0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 0 1 0 1 1 0 1 1 1 1 1 1 1 1 0011 0101 1111 0101 1 0 0 0 0 1 1 1

6 0 1 1 0 0 1 0 1 0 1 1 0 1 0 0 1 1 1 0 0 0 1 0 1 1 1 1 1 0 0011 0110 1111 0110 1 0 0 1 1 1 0 0

7 0 1 1 1 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0 0011 0111 1111 0111 1 0 1 0 1 1 0 1

8 1 0 0 0 1 1 0 0 1 0 0 0 1 0 1 1 1 1 1 0 1 1 0 0 1 1 0 0 0 0011 1000 1111 1000 1 0 1 1 1 1 1 0

9 1 0 0 1 1 1 0 1 1 0 0 1 1 1 0 0 1 1 1 1 1 1 0 1 1 0 0 0 0 0011 1001 1111 1001 1 1 0 0 1 1 1 1

10 1 0 1 0 1 1 1 1

11 1 0 1 1 1 1 1 0

12 1 1 0 0 1 0 1 0

13 1 1 0 1 1 0 1 1 El código llamado Binario Natural es aquel que se expresa en "n" bits 14 1 1 1 0 1 0 0 1 * Codigo Binario Natural de 1 nibble o 4 bits ( n = 4 )

15 1 1 1 1 1 0 0 0 Los códigos BCDs sólo expresan números decimales del 0 al 9

Decimal Códigos de paridad Códigos de distancia unitaria Códigos reflejados Códigos Progresivos Codigo de Hamming

Nº Código Z Código W Código 1 Código 2 Código 3 Código 1 Código 2 I3 I2 I1 I0 P2 P1 P0

0 0000 0 0000 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0

1 0001 1 0001 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 1 0 0 1 0 0 0 1 1 0 0 0 0 1 1 1 1

2 0010 1 0010 0 1 1 0 0 0 0 1 1 1 0 0 1 0 0 1 0 1 0 0 0 1 1 0 0 0 1 1 1 0 0 1 0 1 1 0

3 0011 0 0011 1 1 0 0 0 0 0 1 0 0 0 0 1 0 0 1 1 1 1 1 0 1 0 0 0 0 1 0 1 0 0 1 1 0 0 1

4 0100 1 0100 0 1 0 0 1 0 1 1 0 0 0 1 1 0 1 0 0 0 0 0 0 1 0 0 1 0 1 0 0 0 1 0 0 1 0 1

5 0101 0 0101 1 1 0 1 1 1 1 1 0 0 1 1 1 1 1 0 0 0 0 0 1 1 0 1 1 1 1 0 0 0 1 0 1 0 1 0

6 0110 0 0110 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 0 1 0 1 1 0 1 0 1 1 0 0 1 1

7 0111 1 0111 0 0 1 1 1 1 1 0 1 1 0 1 1 1 0 1 0 1 0 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1 0 0

8 1000 1 1000 0 0 0 1 1 1 1 0 0 1 0 1 0 1 0 0 1 1 0 1 1 1 1 1 1 1 1 1 0 1 0 0 0 0 1 1

9 1001 0 1001 1 0 0 0 1 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0 1 0 1 1 1 1 0 1 0 1 0 0 1 1 0 0

(a) El equivalente decimal se obtiene restando 3 a la suma de sus pesos

(b) El equivalente decimal se obtiene sumando los pesos, excepto para la primera combinación Codigo Z con paridad par; se forma a partir del codigo BCDN más un bit adicional.

Codigo W con paridad impar, se forma a partir del codigo BCDN más un bit adicional.

Código de Hamming: Se forma a partir del código BCDN con 3 bits de paridad par. P2 ( I2,I1,I0 ); P1 ( I3,I1,I0 ); P0 ( I3,I2,I0 ).

(3)

Código Gray

El Código Gray es un caso particular de código binario. Consiste en una ordenación de 2 ⁿ números binarios de tal forma que cada número sólo tenga un dígito binario distinto a su predecesor.

Esta técnica de codificación se originó cuando los circuitos lógicos digitales se realizaban con válvulas de vacío y dispositivos electromecánicos. Los contadores necesitaban potencias muy elevadas a la entrada y generaban picos de ruido cuando varios bits cambiaban simultáneamente. El uso de código Gray garantizó que en cualquier transición variaría tan sólo un bit.

En la actualidad, el código Gray se sigue empleando para el diseño de cualquier circuito electrónico combinacional mediante el uso de un Mapa de Karnaugh, ya que el principio de diseño de buscar transiciones más simples y rápidas entre estados sigue vigente, a pesar de que los problemas de ruido y potencia se hayan reducido.

Hay varios algoritmos para generar una secuencia de código Gray (y varios códigos posibles resultantes, en función del orden que se desee seguir), pero el más usado consiste en cambiar el bit menos significativo que genera un nuevo código.

Este es un código gray de cuatro bits generado con dicho algoritmo:

Dígito

decimal Código Gray Dígito

decimal Código Gray

0 0000 8 1100

1 0001 9 1101

2 0011 10 1111

3 0010 11 1110

4 0110 12 1010

5 0111 13 1011

6 0101 14 1001

7 0100 15 1000

El primer uso documentado de un código de estas características fue en una demostración del telégrafo del ingeniero francés Émile Baudot, en 1878. Pero no fueron patentados hasta 1953 por Frank Gray (que dio nombre al sistema de codificación), un investigador de los laboratorios Bell.

(4)

Código ASCII

Formato de caracteres estándares

ASCII Hex Símbolo

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0 1 2 3 4 5 6 7 8 9 A B C D E F

NUL SOH STX ETX EOT ENQ ACK BEL BS TAB

LF VT FF CR SO SI

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F

DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US

32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F

(espacio)

!

"

#

$

%

&

' ( )

* + , - . /

48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F

0 1 2 3 4 5 6 7 8 9 :

;

<

=

>

?

64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79

40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F

@ A B C D E F G H I J K L M N O

80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F

P Q R S T U V W X Y Z [

\ ]

^ _

96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111

60 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F

` a b c d e f g h i j k l m

n o

112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127

70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F

p q r s t u v w x y z {

| }

~

(5)

TABLA EXTENDIDA DEL 128 AL 255

El código ASCII (acrónimo inglés de American Standard Code for Information Interchange — Código Estadounidense Estándar para el Intercambio de Información), pronunciado generalmente [áski], es un código de caracteres basado en el alfabeto latino tal como se usa en inglés moderno y en otras lenguas occidentales. Fue creado en 1963 por el Comité Estadounidense de Estándares (ASA, conocido desde 1969 como el Instituto Estadounidense de Estándares Nacionales, o ANSI) como una refundición o evolución de los conjuntos de códigos utilizados entonces en telegrafía.

Más tarde, en 1967, se incluyeron las minúsculas, y se redefinieron algunos códigos de control para formar el código conocido como US-ASCII.

El código ASCII utiliza 7 bits para representar los caracteres, aunque inicialmente empleaba un bit adicional (bit de paridad) que se usaba para detectar errores en la transmisión. A menudo se llama incorrectamente ASCII a otros códigos de caracteres de 8 bits, como el estándar ISO-8859-1 que es una extensión que utiliza 8 bits para proporcionar caracteres adicionales usados en idiomas distintos al inglés, como el español.

ASCII fue publicado como estándar por primera vez en 1967 y fue actualizado por última vez en 1986. En la actualidad define códigos para 33 caracteres no imprimibles, de los cuales la mayoría son caracteres de control obsoletos que tienen efecto sobre como se procesa el texto, más otros 95 caracteres imprimibles que les siguen en la numeración (empezando por el carácter espacio).

Casi todos los sistemas informáticos actuales utilizan el código ASCII o una extensión compatible para representar textos y para el control de dispositivos que manejan texto.

(6)

Código EBCDIC

EBCDIC es un código binario que representa caracteres alfanuméricos, controles y signos de puntuación. Cada carácter está compuesto por 1 byte, por eso EBCDIC define un total de 256 caracteres. EBCDIC es un producto de IBM para computadoras.

Dec Hex Code Dec Hex Code Dec Hex Code Dec Hex Code

0 00 NUL 32 20 64 40 space 96 60 -

1 01 SOH 33 21 65 41 97 61 /

2 02 STX 34 22 66 42 98 62

3 03 ETX 35 23 67 43 99 63

4 04 36 24 68 44 100 64

5 05 HT 37 25 LF 69 45 101 65

6 06 38 26 ETB 70 46 102 66

7 07 DEL 39 27 ESC 71 47 103 67

8 08 40 28 72 48 104 68

9 09 41 29 73 49 105 69

10 0A 42 2A 74 4A [ 106 6A |

11 0B VT 43 2B 75 4B . 107 6B ,

12 0C FF 44 2C 76 4C < 108 6C %

13 0D CR 45 2D ENQ 77 4D ( 109 6D _

14 0E SO 46 2E ACK 78 4E + 110 6E >

15 0F SI 47 2F BEL 79 4F | ! 111 6F ?

16 10 DLE 48 30 80 50 & 112 70

17 11 49 31 81 51 113 71

18 12 50 32 SYN 82 52 114 72

19 13 51 33 83 53 115 73

20 14 52 34 84 54 116 74

21 15 53 35 85 55 117 75

22 16 BS 54 36 86 56 118 76

23 17 55 37 EOT 87 57 119 77

24 18 CAN 56 38 88 58 120 78

25 19 EM 57 39 89 59 121 79 ‘

26 1A 58 3A 90 5A ! ] 122 7A :

27 1B 59 3B 91 5B $ 123 7B #

28 1C IFS 60 3C 92 5C * 124 7C @

29 1D IGS 61 3D NAK 93 5D ) 125 7D ‘

30 1E IRS 62 3E 94 5E ; 126 7E =

31 1F IUS 63 3F SUB 95 5F ^ 127 7F "

(7)

Dec Hex Code Dec Hex Code Dec Hex Code Dec Hex Code

128 80 160 A0 192 C0 { 224 E0 \

129 81 a 161 A1 ~ 193 C1 A 225 E1

130 82 b 162 A2 s 194 C2 B 226 E2 S

131 83 c 163 A3 t 195 C3 C 227 E3 T

132 84 d 164 A4 u 196 C4 D 228 E4 U

133 85 e 165 A5 v 197 C5 E 229 E5 V

134 86 f 166 A6 w 198 C6 F 230 E6 W

135 87 g 167 A7 x 199 C7 G 231 E7 X

136 88 h 168 A8 y 200 C8 H 232 E8 Y

137 89 i 169 A9 z 201 C9 I 233 E9 Z

138 8A 170 AA 202 CA 234 EA

139 8B 171 AB 203 CB 235 EB

140 8C 172 AC 204 CC 236 EC

141 8D 173 AD 205 CD 237 ED

142 8E 174 AE 206 CE 238 EE

143 8F 175 AF 207 CF 239 EF

144 90 176 B0 208 D0 } 240 F0 0

145 91 j 177 B1 209 D1 J 241 F1 1

146 92 k 178 B2 210 D2 K 242 F2 2

147 93 l 179 B3 211 D3 L 243 F3 3

148 94 m 180 B4 212 D4 M 244 F4 4

149 95 n 181 B5 213 D5 N 245 F5 5

150 96 o 182 B6 214 D6 O 246 F6 6

151 97 p 183 B7 215 D7 P 247 F7 7

152 98 q 184 B8 216 D8 Q 248 F8 8

153 99 r 185 B9 217 D9 R 249 F9 9

154 9A 186 BA 218 DA 250 FA

155 9B 187 BB 219 DB 251 FB

156 9C 188 BC 220 DC 252 FC

157 9D 189 BD 221 DD 253 FD

158 9E 190 BE 222 DE 254 FE

159 9F 191 BF 223 DF 255 FF

(8)

Bit de Paridad

Un bit de paridad es un dígito binario que indica si el número de bits con un valor de 1 (unos) en un conjunto de bits es par o impar. Los bits de paridad conforman el método de detección de errores más simple.

Hay dos tipos de bits de paridad: bit de paridad par y bit de paridad impar.

El bit de paridad par se pone a 1 si el número de unos en un conjunto de bits es impar, haciendo de esta forma que el número total de bits (datos+paridad) sea par.

El bit de paridad impar se pone a 1 si el número de unos en un conjunto de bits es par, haciendo de esta forma que el número total de bits (datos+paridad) sea impar.

La paridad par es un caso especial del control de redundancia cíclica (CRC), donde el bit de CRC se genera por el polinomio x+1.

Nótese que este método detecta los errores, pero no los corrige (salvo en el caso de que la palabra transmitida sea de tamaño 1 bit).

byte con bit de paridad 7 bits de

datos Par impar

0000000 00000000 00000001 1010001 10100011 10100010 1101001 11010010 11010011 1111111 11111111 11111110

Ejemplos: Tenemos el carácter original 0111001. Vemos que la trama a transmitir tiene un número par de unos (4). Al añadir el bit de paridad obtendremos el siguiente carácter, que es el que se transmitirá a destino:

Si usamos paridad par, ya hay un número par de unos, por tanto se añade un 0, y transmitiremos 00111001

Si usamos paridad impar, como hay un número par de unos, hemos de añadir otro 1 para conseguir un número impar, y transmitiremos 10111001

Si se envía un dato y durante la transmisión se produce un único error, el destinatario puede detectarlo al comprobar la paridad en destino. Usando los ejemplos anteriores, y alterando un solo bit de la trama transmitida, nos quedaría.

Paridad par: se recibe 00110001 en vez de 00111001. Al comprobar el número de unos nos salen 3 (impar), luego se ha producido un error.

Paridad impar, se recibe 10110001 en vez de 10111001. Al comprobar el número de unos nos salen 4 (par), luego se ha producido un error.

Este método, aunque resulta satisfactorio en general, sólo es útil si los errores no cambian un número par de bits a la vez, ya que un número par de errores no afecta a la paridad final de los datos.

(9)

Por tanto, el método de paridad puede detectar un número impar de errores de transmisión.

Siguiendo los ejemplos anteriores, y alterando dos bits en la transmisión, tenemos:

Paridad par: se recibe 00110101 en vez de 00111001. Al comprobar el número de unos nos salen 4 (par), y no detecta los errores.

Paridad impar, se recibe 10110101 en vez de 10111001. Al comprobar el número de unos nos salen 5 (impar), y no detecta los errores.

Bit de redundancia

Es un bit (o conjunto de ellos) que, a veces, se introducen deliberadamente en la transmisión o grabación de información sin ser parte de ésta, pero sirven para detectar posibles errores.

Por ejemplo, si queremos representar cuatro símbolos {1,2,3,4} y hacemos un código sin redundancias, se necesitan dos bits para representarlo.

Si por algún error, obtenemos otro símbolo del alfabeto, no tenemos manera de detectarlo.

Si al código anterior le añadimos un bit al final, se podrán detectar algunos errores determinados.

Si el bit que hemos añadido lo ponemos a cero, y por un error se produce un cambio en el último bit, se detectaría que ese símbolo recibido es un símbolo inválido.

Por ejemplo si recibimos un 001 en vez de un 000, sabríamos que el símbolo recibido es erróneo puesto que no existe en nuestro alfabeto.

Normalmente el valor del bit o de los bits de redundancia se pone con un valor que sea función de alguno o algunos de los bits anteriores, de forma que ayude a identificar errores de comunicación en otros bits. Habitualmente esta función es la suma o XOR de todos los bits anteriores.

Código de Hamming

En informática, el código de Hamming es un código detector y corrector de errores que lleva el nombre de su inventor, Richard Hamming. En los datos codificados en Hamming se pueden detectar errores en uno o en dos bits, y también corregir errores en un solo bit. Esto representa una mejora respecto a los códigos con bit de paridad, que pueden detectar errores en sólo un bit, pero no pueden corregirlo.

*Historia* Hamming trabajó en los laboratorios Bell en los años 40 en la computadora del modelo V de Bell, un monstruo electromecánico basado en relés con velocidad de proceso de varios Hertz.

La entrada se alimentaba con tarjetas perforadas en las que, con frecuencia, se cometían errores al ser leídas. En cada jornada, los errores encontrados se indicaban mediante luces de destello para que los operadores pudieran corregir el problema. Fuera de las horas laborales y durante los fines de semana, cuando no había operadores, la máquina se dejaba preparada para el trabajo de la siguiente jornada.

Hamming trabajando los fines de semana, se sentía frustrado cada vez que tenía que recomenzar sus programas debido a la falta de fiabilidad del lector de tarjetas. Los siguientes años trabajó en el problema de error-corrección, desarrollando un arsenal de algoritmos cada vez más eficaces. En 1950 publicó lo qué ahora se conoce como código de Hamming, que aún hoy sigue siendo utilizado.

(10)

*Códigos Pre-Hamming* Antes de los códigos Hamming se utilizaron ciertos códigos detectores de error, pero ninguno llegó a ser tan eficaz como los de Hamming. A continuación se describen algunos de estos códigos.

*Paridad* La paridad consiste en añadir un bit, denominado bit de paridad, que indique si el número de los bits de valor 1 en los datos precedentes es par o impar. Si un solo bit cambiara por error en la transmisión, el mensaje cambiará de paridad y el error se puede detectar (nótese que el bit donde se produzca el error puede ser el mismo bit de paridad). La convención más común es que un valor de paridad de 1 indica que hay un número impar de unos en los datos, y un valor de

paridad de 0 indica que hay un número par de unos en los datos.

La comprobación de paridad no es muy robusta, dado que si cambia de forma uniforme más de un solo bit, el bit de paridad será válido y el error no será detectado. Por otro lado, la paridad, aunque puede detectar que hay error, no indica en qué bit se cometió. Los datos se deben desechar por entero y volverse a retransmitir. En un medio ruidoso, una transmisión correcta podría tardar mucho tiempo o incluso, en el peor de los casos, no darse nunca. El chequeo de paridad, aunque no es muy bueno, usa un único bit, por lo que produce muy poca sobrecarga, y además permite la corrección de ese bit si es conocida su posición.

*Dos entre cinco* En los años 40 Bell utilizó un código algo más sofisticado conocido como dos- entre-cinco. Este código se basa en que cada bloque de cinco bits (conocido como penta-bit) tuviera exactamente dos unos. De este modo, la computadora podría detectar posibles errores cuando en su entrada no había exactamente dos unos en cada penta-bit.

Este código seguía únicamente detectando errores por cambio en un solo bit; si en un mismo penta- bit un 0 cambiaba a 1 y un 1 cambiaba a 0, la regla de dos-entre-cinco se seguía cumpliendo y el error quedaba sin descubrir.

*Repetición* Otro código utilizado consistía en repetir cada bit de datos varias veces para

asegurarse de que la transmisión era correcta. Por ejemplo, si el bit de datos que se enviará fuera un 1, un código de repetición con n=3, enviaría "111". Si los tres bits recibidos no eran idénticos, había un error. En un ambiente sin demasiado ruido, la mayoría de las veces solamente cambiaría un bit en cada paquete de tres bits. Por lo tanto, datos del tipo 001, 010, y 100 se corresponden al bit 0, mientras que 110, 101, y 011 se corresponden con el bit 1. Es como si el bit original se obtuviera por mayoría en una "votación". Un código con esta capacidad de reconstruir el mensaje original en la presencia de errores se conoce como código corrector de errores.

Sin embargo, este código no puede reparar correctamente todos los errores. En nuestro ejemplo, si el error en la transmisión provocara el cambio simultáneo de dos bits y el receptor recibiera "001", el sistema detectaría el error, pero considerando que el bit original era 0, lo cual es incorrecto. Si se aumenta el número de veces que se repite cada bit a cuatro (n=4), es posible detectar los errores en dos bits pero obviamente no se podrán corregir; con cinco, es posible corregir errores de dos bits, pero no lo podrá hacer en errores de tres bits.

Por otra parte, el código de la repetición es extremadamente ineficaz, pues reduce la velocidad de transmisión por tres en nuestro ejemplo original y su eficacia cae drásticamente al aumentar el número de veces que cada bit se repite para detectar y corregir más errores.

(11)

*Códigos Hamming* Si se añaden junto al mensaje más bits detectores-correctores de error y si esos bits se pueden ordenar de modo que diferentes bits de error producen diferentes resultados, entonces los bits erróneos podrían ser identificados. En un conjunto de siete bits, hay sólo siete posibles errores de bit, por lo que con tres bits de control de error se podría especificar además de que ocurrió un error, qué bit fue el que lo causó.

Hamming estudió los esquemas de codificación existentes, incluido el de dos entre cinco, y generalizó sus conclusiones. Para empezar, desarrolló una nomenclatura para describir el sistema, incluyendo el número de los bits de datos y el de los bits detectores-correctores de error en un bloque. Por ejemplo, la paridad incluye un solo bit para cualquier palabra de datos, así que las palabras del Código ASCII que son de siete bits, Hamming las describía como un código (8.7), esto es, un total de 8 bits de los cuales 7 son datos. En el ejemplo anterior de la repetición, sería un código (3.1), siguiendo la misma lógica. La relación de la información es el segundo número dividido por el primero, por nuestro ejemplo de la repetición, 1/3.

Hamming también estudió los problemas que surgían al cambiar dos o más bits a la vez y describió esto como "distancia" (ahora llamada distancia de Hamming en su honor). La paridad tiene una distancia de 2, dado que cualquier error en dos bits no será detectado. La repetición (3.1)tiene una distancia de 3, pues son necesarios el cambio simultáneo de tres bits para obtener otra palabra de código. La repetición (4.1) (cada bit se repite cuatro veces) tiene una distancia de 4, así que el cambio de dos bits en el mismo grupo quedará sin definir.

Hamming estaba interesado en solucionar simultáneamente dos problemas: aumentar la distancia tanto como sea posible, a la vez que se aumentan al máximo los bits de información. Durante los años 40 desarrolló varios esquemas de codificación que mejoraban notablemente los códigos existentes. La clave de todos sus sistemas era intercalar entre los bits de datos los de paridad.

*Hamming (7,4)* Hoy, el código de Hamming se refiere al (7.4) que Hamming introdujo en 1950.

El código de Hamming agrega tres bits adicionales de comprobación por cada cuatro bits de datos del mensaje.

El algoritmo de Hamming (7.4) puede corregir cualquier error de un solo bit, y detecta todos los errores de dos bits.

Para un ambiente en el que el ruido pueda cambiar como máximo 2 bits de 7, el código Hamming (7.4) es generalmente el de pérdida mínima.

El medio tendría que ser muy ruidoso para que se perdieran más de 2 bits de cada 7 (casi el 45% de los bits transmitidos), y habría que considerar seriamente cambiar a un medio de transmisión más fiable.

El algoritmo es simple:

1. Todos los bits cuya posición es potencia de dos se utilizan como bits de paridad (posiciones 1, 2, 4, 8, 16, 32, 64, etc.).

2. Los bits del resto de posiciones son utilizados como bits de datos (posiciones 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 17, etc.).

(12)

3. Cada bit de paridad se obtiene calculando la paridad de alguno de los bits de datos. La posición del bit de paridad determina la secuencia de los bits que alternativamente comprueba y salta, a partir de éste, tal y como se explica a continuación.

Posición 1: comprueba 1, salta 1, comprueba 1, etc.

Posición 2: comprueba 1, salta 2, comprueba 2, salta 2, comprueba 2, etc.

Y así sucesivamente.

En otras palabras, el bit de paridad de la posición 2 comprueba los bits en las posiciones que ^k tengan al bit k en su representación binaria. Dicho a la inversa, el bit 13, por ejemplo, es chequeado por los bits 8, 4 y 1, al ser estos los de su representación binaria: 13=1101₍₂₎; 8=1000₍₂₎; 4=0100₍₂₎; 1=0001₍₂₎.

Así pues en la Posición 1, comprobaríamos los bits: 3, 5, 7, 9, 11...; en la Posición 2, los bits: 3, 6, 7, 10, 11, 14, 15...-; en la Posición 4 tendríamos: 5, 6, 7, 12, 13, 14, 15... Así hasta completar la nueva cadena.

Ejemplo:

Consideremos la palabra de datos de 7 bits "0110101". Para ver cómo se generan y utilizan los códigos Hamming para detectar un error, observe las tablas siguientes. Se utiliza la d para indicar los bits de datos y la p para los de paridad.

En primer lugar los bits de datos se insertan en las posiciones apropiadas y los bits de paridad calculados en cada caso usando la paridad par.

(13)

p

1

p

2

d

1

p

3

d

2

d

3

d

4

p

4

d

5

d

6

d

7

Palabra de datos (sin paridad): 0 1 1 0 1 0 1

P1 1 0 1 0 1 1

P2 0 0 1 0 0 1

P3 0 1 1 0

P4 0 1 0 1

Palabra de datos (con

paridad): 1 0 0 0 1 1 0 0 1 0 1

Cálculo de los bits de paridad en el código Hamming

La nueva palabra de datos (con los bits de paridad) es ahora "10001100101". Consideremos ahora que el bit de la derecha, por error, cambia de 1 a 0. La nueva palabra de datos será ahora

"10001100100"; cuando se analice el modo en que se obtienen los bits de paridad en los códigos de Hamming se observarán variaciones en la paridad, lo que significará que hay error.

(14)

p

1

p

2

d

1

p

3

d

2

d

3

d

4

p

4

d

5

d

6

d

7

Prueba de paridad

Bit de paridad

Palabra de datos

recibida: 1 0 0 0 1 1 0 0 1 0 0 1

p1 1 0 1 0 1 0 Error 1

p2 0 0 1 0 0 0 Error 1

p3 0 1 1 0 Correcto 0

p4 0 1 0 0 Error 1

Comprobación de los bits de paridad (con primer bit de la derecha cambiado)

El paso final es evaluar los bits de paridad (recuerde que el fallo se encuentra en d7). El valor entero que representan los bits de paridad es 11, lo que significa que el bit décimo primero de la palabra de datos (bits de paridad incluidos) es el erróneo y necesita ser cambiado.

p

4

p

3

p

2

p

1

Binario 1 0 1 1

Decimal 8 2 1 Σ = 11

Cambiando el bit décimo primero 10001100100 se obtiene de nuevo 10001100101. Eliminando los bits de paridad de Hamming se vuelve a obtener la palabra de datos original 0110101.

Observe que en la comprobación de la paridad no se tienen en cuenta los bits de paridad. Si el error se produjera en uno de ellos, en la comprobación sólo se detectaría un error, justo el

correspondiente al bit de paridad causante del mismo.

(15)

Finalmente, cuando cambien dos bits, en la comprobación de paridad se obtendrá un valor decimal superior a 11, detectándose el error; sin embargo no se podrá saber las posiciones de los dos bits que cambiaron.

CRC

Los códigos cíclicos también se llaman CRC (Códigos de Redundancia Cíclica) o códigos polinómicos. Su uso está muy extendido porque pueden implementarse en hardware con mucha facilidad y son muy potentes.

Estos códigos se basan en el uso de un polinomio generador G(X) de grado r, y en el principio de que n bits de datos binarios se pueden considerar como los coeficientes de un polinomio de orden n-1.

Por ejemplo, los datos 10111 pueden tratarse como el polinomio x⁴ + x² + x¹ + x⁰

A estos bits de datos se le añaden r bits de redundancia de forma que el polinomio resultante sea divisible por el polinomio generador. El receptor verificará si el polinomio recibido es divisible por G(X). Si no lo es, habrá un error en la transmisión.

Los bits de datos se dividen en bloques (llamados frames en inglés), y a cada bloque se le calcula r, que se denomina secuencia de comprobación de bloque (Frame Check Sequence, FCS, en inglés) Los polinomios generadores más usados son:

CRC-12: x¹² + x¹¹ + x³ + x² + x¹ + 1. Usado para transmitir flujos de 6 bits, junto a otros 12 de redundancia. Es decir, usa bloques de 6 bits, a los que les une un FCS que genera de 12 bits.

CRC-16: x¹⁶ + x¹⁵ + x² + 1. Para flujos de 8 bits, con 16 de redundancia. Usado en Estados Unidos, principalmente.

CRC-CCITT: x¹⁶ + x¹² + x⁵ + 1. Para flujos de 8 bits, con 16 de redundancia. Usado en Europa, principalmente.

CRC-32: x³² + x²⁶ + x²³ + x²² + x¹⁶ + x¹² + x¹¹ + x¹⁰ + x⁸ + x⁷ + x⁵ + x⁴ + x² + x + 1. Da una

protección extra sobre la que dan los CRC de 16 bits, que suelen dar la suficiente. Se emplea por el comité de estándares de redes locales (IEEE 802) y en algunas aplicaciones del Departamento de Defensa de Estados Unidos.

Si tenemos un polinomio generador tal que G(x)=x²+1 podremos obtener a partir de él que el CRC es capaz de detectar todos los errores impares, genera una redundancia de 2 bits y no será capaz de detectar todos los errores dobles, por ejemplo una secuencia error-válido pasaría siempre

inadvertida.

El algoritmo utilizado por el control de redundancia cíclica es el siguiente:

Se añaden r bits "0" a la derecha del mensaje (esto es, se añaden tantos ceros como grado tenga el polinomio generador).

Se divide el polinomio obtenido por el polinomio generador. La división se realiza en módulo 2, que es igual que la división binaria, con dos excepciones:

(16)

1 + 1 = 0 (no hay acarreo) y 0 - 1 = 1 (no hay acarreo) Y se añade el resto de la división al polinomio original

La elección del polinomio generador es esencial si queremos detectar la mayoría de los errores que ocurran.

Uno de los polinomios generadores que más se suelen utilizar es el estándar CCITT:

x¹⁶ + x¹² + x⁵ + 1.

Este polinomio permite la detección de:

* 100% de errores simples.

* 100% de errores dobles.

* 100% de errores de un número impar de bits.

* 100% de errores en ráfagas (en una serie sucesiva de bits) de 16 o menos bits.

* 99.99% de errores en ráfagas de 18 o más bits.

(17)

Código ISO 8859-1

ISO 8859-1 es una norma de la ISO que define la codificación del alfabeto latino, incluyendo los diacríticos (como letras acentuadas, ñ, ç), y letras especiales (como ß, Ø), necesarios para la escritura de las siguientes lenguas originarias de Europa occidental: afrikaans, alemán, aragonés, catalán, danés, escocés, español, feroés, finés, francés, gaélico, gallego, inglés, islandés, italiano, neerlandés, noruego, portugués, sueco y vasco.

También conocida como Alfabeto Latino n.º 1 o ISO Latín 1.

Esta norma pertenece al grupo de juegos de caracteres de la ISO conocidos como ISO-8859 que se caracterizan por poseer la codificación ASCII en su rango inicial (128 caracteres) y otros 128 caracteres para cada codificación, con lo que en total utilizan 8 bits.

Los caracteres de ISO-8859-1 son además los primeros 256 caracteres del estándar ISO 10646 (Unicode).

Caracteres de ISO Latín 1

A continuación los caracteres imprimibles de la norma que no pertenecen al subconjunto ASCII:

Oct Dec Hex Carac Descripción

--- 240 160 A0 ESPACIO DE "NO RUPTURA"

241 161 A1 ¡ SIGNO DE EXCLAMACIÓN ABIERTA 242 162 A2 ¢ SIGNO DE CENTAVO

243 163 A3 £ SIGNO DE LIBRA ESTERLINA 244 164 A4 ¤ SIGNO MONETARIO

245 165 A5 ¥ SIGNO DEL YEN

246 166 A6 ¦ BARRA VERTICAL PARTIDA 247 167 A7 § SIGNO DE SECCIÓN

250 168 A8 ¨ DIÉRESIS

253 171 AB « SIGNO DE COMILLAS FRANCESAS DE APERTURA 254 172 AC ¬ SIGNO DE NEGACIÓN

255 173 AD - GUIÓN SEPARADOR DE SÍLABAS 256 174 AE ® SIGNO DE MARCA REGISTRADA 257 175 AF ¯ MACRÓN

260 176 B0 ° SIGNO DE GRADO 261 177 B1 ± SIGNO MÁS-MENOS 262 178 B2 ² SUPERÍNDICE DOS 263 179 B3 ³ SUPERÍNDICE TRES 264 180 B4 ´ ACENTO AGUDO 265 181 B5 µ SIGNO DE MICRO 266 182 B6 ¶ SIGNO DE CALDERÓN 267 183 B7 · PUNTO CENTRADO 270 184 B8 ¸ CEDILLA

271 185 B9 ¹ SUPERÍNDICE 1

272 186 BA º INDICADOR ORDINAL MASCULINO

273 187 BB » SIGNO DE COMILLAS FRANCESAS DE CIERRE 274 188 BC ¼ FRACCIÓN VULGAR DE UN CUARTO

275 189 BD ½ FRACCIÓN VULGAR DE UN MEDIO 276 190 BE ¾ FRACCIÓN VULGAR DE TRES CUARTOS 277 191 BF ¿ SIGNO DE INTERROGACIÓN ABIERTA

(18)

300 192 C0 À A MAYÚSCULA CON ACENTO GRAVE 301 193 C1 Á A MAYÚSCULA CON ACENTO AGUDO 302 194 C2 Â A MAYÚSCULA CON CIRCUNFLEJO 303 195 C3 Ã A MAYÚSCULA CON TILDE

304 196 C4 Ä A MAYÚSCULA CON DIÉRESIS

305 197 C5 Å A MAYÚSCULA CON CÍRCULO ENCIMA 306 198 C6 Æ AE MAYÚSCULA

307 199 C7 Ç C MAYÚSCULA CON CEDILLA 310 200 C8 È E MAYÚSCULA CON ACENTO GRAVE 311 201 C9 É E MAYÚSCULA CON ACENTO AGUDO 312 202 CA Ê E MAYÚSCULA CON CIRCUNFLEJO 313 203 CB Ë E MAYÚSCULA CON DIÉRESIS 314 204 CC Ì I MAYÚSCULA CON ACENTO GRAVE 315 205 CD Í I MAYÚSCULA CON ACENTO AGUDO 316 206 CE Î I MAYÚSCULA CON CIRCUNFLEJO 317 207 CF Ï I MAYÚSCULA CON DIÉRESIS 320 208 D0 Ð ETH MAYÚSCULA

321 209 D1 Ñ N MAYÚSCULA CON TILDE (EÑE) 322 210 D2 Ò O MAYÚSCULA CON ACENTO GRAVE 323 211 D3 Ó O MAYÚSCULA CON ACENTO AGUDO 324 212 D4 Ô O MAYÚSCULA CON CIRCUNFLEJO 325 213 D5 Õ O MAYÚSCULA CON TILDE

326 214 D6 Ö O MAYÚSCULA CON DIÉRESIS

327 215 D7 × SIGNO DE MULTIPLICACIÓN (ASPA) 330 216 D8 Ø O MAYÚSCULA CON BARRA INCLINADA 331 217 D9 Ù U MAYÚSCULA CON ACENTO GRAVE 332 218 DA Ú U MAYÚSCULA CON ACENTO AGUDO 333 219 DB Û U MAYÚSCULA CON CIRCUNFLEJO 334 220 DC Ü U MAYÚSCULA CON DIÉRESIS 335 221 DD Ý Y MAYÚSCULA CON ACENTO AGUDO 336 222 DE Þ THORN MAYÚSCULA

337 223 DF ß S AGUDA ALEMANA

340 224 E0 à A MINÚSCULA CON ACENTO GRAVE 341 225 E1 á A MINÚSCULA CON ACENTO AGUDO 342 226 E2 â A MINÚSCULA CON CIRCUNFLEJO 343 227 E3 ã A MINÚSCULA CON TILDE

344 228 E4 ä A MINÚSCULA CON DIÉRESIS

345 229 E5 å A MINÚSCULA CON CÍRCULO ENCIMA 346 230 E6 æ AE MINÚSCULA

347 231 E7 ç C MINÚSCULA CON CEDILLA 350 232 E8 è E MINÚSCULA CON ACENTO GRAVE 351 233 E9 é E MINÚSCULA CON ACENTO AGUDO 352 234 EA ê E MINÚSCULA CON CIRCUNFLEJO 353 235 EB ë E MINÚSCULA CON DIÉRESIS 354 236 EC ì I MINÚSCULA CON ACENTO GRAVE 355 237 ED í I MINÚSCULA CON ACENTO AGUDO 356 238 EE î I MINÚSCULA CON CIRCUNFLEJO 357 239 EF ï I MINÚSCULA CON DIÉRESIS 360 240 F0 ð ETH MINÚSCULA

361 241 F1 ñ N MINÚSCULA CON TILDE (EÑE) 362 242 F2 ò O MINÚSCULA CON ACENTO GRAVE 363 243 F3 ó O MINÚSCULA CON ACENTO AGUDO 364 244 F4 ô O MINÚSCULA CON CIRCUNFLEJO 365 245 F5 õ O MINÚSCULA CON TILDE

366 246 F6 ö O MINÚSCULA CON DIÉRESIS 367 247 F7 ÷ SIGNO DE DIVISIÓN

370 248 F8 ø O MINÚSCULA CON BARRA INCLINADA 371 249 F9 ù U MINÚSCULA CON ACENTO GRAVE 372 250 FA ú U MINÚSCULA CON ACENTO AGUDO 373 251 FB û U MINÚSCULA CON CIRCUNFLEJO 374 252 FC ü U MINÚSCULA CON DIÉRESIS 375 253 FD ý Y MINÚSCULA CON ACENTO AGUDO 376 254 FE þ THORN MINÚSCULA

377 255 FF ÿ Y MINÚSCULA CON DIÉRESIS