Binario y hexadecimal

01 · Punto de partida

Diez dedos, dos niveles

Contamos de a diez porque tenemos diez dedos. Un cable digital tiene dos estados, así que su «aritmética natural» es de a dos: un cable, un bit; ocho cables, ocho bits, 256 combinaciones. Todo lo que un circuito digital sabe de números lo sabe en base 2.

• ¿Cómo se lee un número binario con los pesos de cada posición?
• ¿Cómo se pasa de decimal a binario y de binario a hexadecimal sin calculadora?
• ¿Cuánto entra en 4, 8, 12 o 16 bits?
• ¿Qué son MSB y LSB, y por qué el orden importa?
• ¿Qué hacen los desplazamientos y las máscaras?

02 · Sistema posicional

Contar con pesos, no con magia

El decimal ya es un sistema posicional: en 305 el «3» vale 300 porque está en la posición de las centenas. Cada posición vale 10 veces la anterior. El binario hace lo mismo con una sola diferencia: cada posición vale el doble.

Un número binario se lee sumando el peso de cada posición donde hay un 1. Por ejemplo, 1101 tiene unos en los pesos 8, 4 y 1:

Contar en binario es contar igual que en decimal, pero «se acaban los dígitos» antes: al llegar a 1 hay que llevarse uno a la posición siguiente.

Fijate en cómo cambia cada bit al contar de 0 a 15 en orden: el de la derecha alterna 0, 1, 0, 1 en cada número; el siguiente alterna cada dos números; el siguiente cada cuatro. Cada bit cambia a la mitad de velocidad que el anterior. Esa observación es exactamente cómo funciona un contador digital (curso 6).

Bit

Un dígito binario: 0 o 1. Es la unidad mínima de información y, en hardware, un cable.

Nibble

Un grupo de 4 bits. Vale de 0 a 15 y corresponde a exactamente un dígito hexadecimal.

Byte

Un grupo de 8 bits (dos nibbles). Vale de 0 a 255.

Palabra (word)

El ancho natural de un procesador: 8, 16, 32 o 64 bits. Depende del chip.

03 · Conversión

Decimal ↔ binario

Hay dos métodos para pasar un decimal a binario. Los dos sirven; conviene dominar el primero para cuentas rápidas y el segundo para entender cómo lo haría un programa.

1. 1
   Restar la potencia más grande.

   Para 165: la mayor potencia que entra es 128 (queda 37); luego 32 (queda 5); luego 4 (queda 1); luego 1. Los pesos usados son 128, 32, 4 y 1 → 10100101. Se marca 1 donde se restó y 0 donde se saltó.

2. 2
   Dividir por 2 y anotar los restos.

   165 ÷ 2 = 82 resto 1; 82 ÷ 2 = 41 resto 0; 41 ÷ 2 = 20 resto 1; y así hasta llegar a 0. Los restos, leídos de abajo hacia arriba, son los bits: 10100101.

3. 3
   Binario a decimal: sumar pesos.

   Para 1101: 8 + 4 + 0 + 1 = 13. En un programa se hace recorriendo los bits de izquierda a derecha con v = v * 2 + bit (lo vas a ver en la sección 08).

04 · Hexadecimal

Binario con buena letra

Un número binario largo es difícil de leer y de copiar sin errores: 1010010111000011 mareó a cualquiera. El hexadecimal (base 16) resuelve eso con un truco: cada dígito hexadecimal representa exactamente un nibble. No hay que calcular nada, solo agrupar de a cuatro.

Para pasar de binario a hexadecimal se parte el número en grupos de 4 bits, de derecha a izquierda, y se reemplaza cada grupo por su dígito:

Para pasar de hexadecimal a decimal: el primer dígito pesa 16 y el segundo pesa 1. En 0xA5: 10 × 16 + 5 = 165. Con más dígitos, cada posición pesa 16 veces la anterior (1, 16, 256, 4096…).

05 · Rangos

Cuánto entra por ancho

Con N bits hay 2^N combinaciones distintas, así que se pueden representar los números de 0 a 2^N − 1 (sin signo). Cada bit extra duplica la capacidad.

La pregunta inversa también aparece: ¿cuántos bits necesito para guardar hasta el valor M? Se busca la menor N tal que 2^N − 1 ≥ M. Para 100 valores distintos hacen falta 7 bits (rango 0 a 127); para 1000, 10 bits (0 a 1023); para 5000, 13 bits.

06 · Orden y manipulación

MSB, LSB, desplazamientos y máscaras

Los bits de un número no valen todos lo mismo. El de más a la izquierda, con el peso mayor, es el MSB (most significant bit); el de la derecha, de peso 1, es el LSB (least significant bit). Tocar el MSB de 165 resta 128; tocar el LSB resta 1.

Orden en serie (endianness)

Cuando los bits viajan uno a uno por un cable, hay que acordar cuál sale primero: MSB primero o LSB primero. La UART del Tema 2 enviaba el LSB primero; SPI suele enviar el MSB primero. Si emisor y receptor no acuerdan, un 0x41 se lee como 0x82.

Desplazar a la izquierda (<<)

Mover todos los bits una posición a la izquierda y entrar un 0 por la derecha. Equivale a multiplicar por 2. 45 << 1 = 90. Si el MSB se pierde, el resultado deja de ser correcto.

Desplazar a la derecha (>>)

Mover los bits una posición a la derecha. Equivale a dividir por 2 (descartando el resto). 45 >> 1 = 22.

Máscara con AND (&)

Para leer ciertos bits: poner en 0 todo lo que no interesa. x & 0x0F deja solo el nibble bajo.

OR (|) y XOR (^)

OR con una máscara enciende bits; XOR los invierte. x | 0x80 pone el MSB en 1; x ^ 0xFF invierte los ocho bits.

Estas operaciones son lo que el hardware hace «gratis»: un desplazamiento no es un cálculo sino un recableado, y una máscara es una puerta AND por bit (Temas 8 y 9). Por eso los programadores de bajo nivel las usan tanto para configurar registros.

07 · Simulador

Laboratorio: ocho interruptores

El simulador muestra un byte como ocho interruptores. Prendé y apagá bits, movés el deslizador o aplicás operaciones, y mirá cómo cambian el decimal, el hexadecimal y la suma de pesos. También te dice qué voltaje representaría ese byte en un conversor de 8 bits con rango de 0 a 5 V (el puente con el Tema 1).

• Cajas amarillas: los bits en 1. Debajo de cada una se ve el peso que aporta a la suma.
• Corchetes bajo las cajas: los dos nibbles. Encima de cada uno, el dígito hexadecimal que le corresponde.
• Botones de operación: desplazar, invertir, sumar y restar 1. El mensaje inferior te avisa cuando un desplazamiento pierde un bit.

Recorrido guiado (5 minutos)

1. 1
   Mirá el byte inicial (165).

   Los unos están en los pesos 128, 32, 4 y 1. Los nibbles son 1010 (A) y 0101 (5): el hexadecimal sale de leerlos sin calcular.

2. 2
   Apagá el bit de 128 y después el de 1.

   El primero resta 128 (165 → 37) y el segundo resta 1 (165 → 164). Mismo gesto, impacto distinto: el peso manda.

3. 3
   Armá 255 con los ocho interruptores.

   Todo en 1 = 0xFF, el máximo de un byte. Ahora apretá «+ 1»: el resultado es 0. Es el desborde del apartado 05: no da error, da la vuelta.

4. 4
   Con 45 (00101101) apretá «<< 1» varias veces.

   45 → 90 → 180: se duplica en cada paso. Al siguiente (360) no cabe en 8 bits: el MSB se pierde y queda 104. El mensaje avisa del desborde.

5. 5
   Con 165 apretá «>> 1».

   165 → 82 → 41: se divide por 2 y el bit que sale por la derecha se descarta. Dividir y luego multiplicar no devuelve el original.

6. 6
   Apretá «Invertir (NOT)» sobre 165.

   Los 1 pasan a 0 y viceversa: 165 (10100101) se vuelve 90 (01011010). Siempre se cumple que x + NOT(x) = 255 en 8 bits.

Preguntas para pensar

1. Armá 0x3C con los interruptores. ¿Cuál es su decimal y qué interruptores están encendidos?
2. ¿Qué diferencia hay, en valor decimal, entre apagar el MSB de 165 y apagar su LSB?
3. Partiendo de 1, ¿cuántas veces podés aplicar «<< 1» antes de perder el único bit en 1?

08 · Bases en código

Convertir sin calculadora (y verificar)

Python ya sabe de bases, pero escribir las conversiones a mano fija la idea. Primero mostrá un número en las tres notaciones, después reproducí los algoritmos del apartado 03.

Paso 1: un número, tres notaciones

def mostrar(n, bits=8):
    b = format(n, f"0{bits}b")
    h = format(n, f"0{bits // 4}X")
    suma = " + ".join(str(2 ** (bits - 1 - i)) for i, c in enumerate(b) if c == "1") or "0"
    print(f"{n:>3} = {b[:bits // 2]}_{b[bits // 2:]} = 0x{h}  ({suma})")
    return b


for n in (165, 13, 255, 60, 0):
    mostrar(n)

165 = 1010_0101 = 0xA5. 13 = 0000_1101 = 0x0D. ¿Qué número es 0x3C? ¿Y con bits=16?

Paso 2: de binario a decimal (sumar pesos)

def a_decimal(txt):
    v = 0
    for ch in txt.replace("_", "").strip():
        v = v * 2 + (ch == "1")
    print(f"{txt} = {v} = 0x{v:X}")
    return v


a_decimal("1101")
a_decimal("10100101")
a_decimal("00111100")

Cada vuelta duplica lo acumulado y suma el bit nuevo. Probá "11111111" y "1000_0000".

Paso 3: de decimal a binario (dividir por 2)

def divisiones(n):
    pasos, x = [], n
    while x:
        pasos.append(f"{x}/2 = {x // 2} resto {x % 2}")
        x //= 2
    print(f"{n}:", " | ".join(pasos))
    print("  restos leídos al revés:", format(n, "b"))


divisiones(13)
divisiones(165)

13 da 6, 3, 1, 0 con restos 1, 0, 1, 1: leídos al revés, 1101. ¿Cuántas divisiones necesita un número de 8 bits?

Paso 4: ¿cuántos bits necesito?

def bits_necesarios(maximo):
    n = 1
    while 2 ** n - 1 < maximo:
        n += 1
    print(f"para llegar a {maximo} hacen falta {n} bits (rango 0..{2 ** n - 1})")
    return n


for m in (1, 9, 100, 255, 256, 1000, 4095, 5000):
    bits_necesarios(m)

255 cabe en 8 bits y 256 ya necesita 9: un solo valor de más cuesta un bit entero. ¿Cuántos bits para guardar los minutos de un día (1440)?

Paso 5: desplazamientos, máscaras y un color

x = 0b00101101
print(f"x = {x:08b} ({x})")
print(f"x << 1 = {(x << 1) & 0xFF:08b} ({(x << 1) & 0xFF})   "
      f"x << 2 = {(x << 2) & 0xFF:08b} ({(x << 2) & 0xFF})")
print(f"x >> 1 = {x >> 1:08b} ({x >> 1})")

y = 0b11001101
print(f"y << 1 en 8 bits = {(y << 1) & 0xFF:08b}: se pierde el bit {(y >> 7) & 1}")

print(f"x & 0x0F = {x & 0x0F:08b}   x & 0xF0 = {x & 0xF0:08b}")
print(f"x | 0x80 = {x | 0x80:08b}   x ^ 0xFF = {x ^ 0xFF:08b}")


def color(hexa):
    h = hexa.lstrip("#")
    r, g, b = (int(h[i:i + 2], 16) for i in (0, 2, 4))
    print(f"#{h.upper()} -> R={r} G={g} B={b}  ({r:08b} {g:08b} {b:08b})")


color("#FF5733")
color("#00FF7F")
color("#808080")

45 << 1 = 90 y 45 >> 1 = 22 (se pierde el resto). #FF5733 es R=255, G=87, B=51. ¿Qué color es #808080? ¿Y #000000?

09 · Analogía de programador

Flags, volcados y máscaras

Casi todo lo de este tema ya lo usaste sin llamarlo así. Poné nombre a esas herramientas y la electrónica pasa a ser conocida.

1. 1
   Bits = flags.

   Los permisos Unix 755 son tres grupos de tres bits: el binario ya gobierna tus archivos.

2. 2
   Hex = volcado legible.

   Ver memoria en hexadecimal es ver binario con buena letra. Cada dígito, un nibble exacto.

3. 3
   Pesos = potencias de 2.

   128, 64, 32… están por todas partes: 1 KiB son 1024 bytes, los puertos TCP llegan a 65 535, los colores tienen 256 niveles.

La diferencia con un lenguaje de programación es que ahí el ancho lo declarás con un tipo y el compilador te cuida las espaldas. En el hardware, el ancho es la cantidad de cables que tendiste: si el número no cabe, no hay error ni excepción, simplemente se pierde el bit que no tiene dónde ir.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Ejercicios de bases

Ejercicio 1: contar hasta 15

Escribí a mano los números de 0 a 15 en binario de 4 bits. Después verificá el 13 y el 10 con a_decimal().

Ejercicio 2: de hexadecimal a decimal

Convertí 0x1F, 0x80 y 0xC3 a decimal a mano. Verificá con int("C3", 16).

Ejercicio 3: DIP switch

Un DIP switch de 8 posiciones (numeradas 1 a 8 con el MSB primero) debe quedar en 0x3C, la dirección de una pantalla OLED. ¿Qué posiciones van en ON?

Ejercicio 4: elegir el ancho

Un sensor de posición entrega 600 posiciones distintas. Otro cuenta hasta 1440 minutos de un día. ¿Cuántos bits necesita cada uno? Verificá con bits_necesarios().

Ejercicio 5: descomponer un color

El color #FF5733 tiene tres bytes. Pasalos a decimal y a binario. ¿Qué color da cada canal por sí solo y cuánto aporta el verde en porcentaje?

12 · Síntesis

Ideas para recordar

¿Listo para el Tema 5?

Podés avanzar si sos capaz de responder esto sin mirar:

• Convertir 100 a binario y a hexadecimal sin calculadora.
• Leer 0xC3 como bits y como decimal.
• Decir cuántos valores distintos hay en 10 bits y cuál es el máximo.
• Calcular cuántos bits hacen falta para contar hasta 300.
• Explicar qué le pasa a 255 al sumarle 1 en un byte.
• Describir qué hacen << 1, & 0x0F, | 0x80 y ^ 0xFF.

Ya sabés contar en la base del silicio. Ahora, ¿cómo se escribe un número negativo, un carácter o una fecha con bits? En el próximo tema, representación de información digital.