4. Binario y hexadecimal | Electrónica Digital para Programadores

01 · Punto de partida

Diez dedos, dos niveles

Contamos en 10 porque tenemos 10 dedos; el silicio cuenta en 2 porque tiene 2 niveles. El hexadecimal (16) es el compromiso: un dígito por nibble (4 bits). 0xA5 se lee de un vistazo; 10100101 no.

¿Cómo se lee un binario por pesos?
¿Cómo se agrupa a hex?
¿Cuánto abarca cada ancho?
¿Qué atajos usan los programadores?

02 · Binario

Pesos, no magia

Cada posición vale el doble: 13 = 8+4+1 = 1101; 255 = todos unos (8 bits). Para convertir: restar la potencia más grande que entre, marcar 1, seguir.

13 = 8 + 4 + 1 = 1101₂

decimal → restar potencias →unos y ceros →agrupar de a 4

03 · Hexadecimal

Binario compacto

Nibble a hex (0–15).
Bin	Dec	Hex	Bin	Dec	Hex
0000	0	0	1000	8	8
0001	1	1	1001	9	9
0010	2	2	1010	10	A
0011	3	3	1011	11	B
0100	4	4	1100	12	C
0101	5	5	1101	13	D
0110	6	6	1110	14	E
0111	7	7	1111	15	F

0xA5 = 1010·0101 = 160+5 = 165. Direcciones, registros y colores (#FF5733) viven en hex: es binario con buena letra.

04 · Rangos

Cuánto entra por ancho

Rango sin signo por ancho.
Bits	Rango	Dónde lo ves
4	0–15	Nibble, 7 segmentos
8	0–255	Byte, ADC, 0xFF
12	0–4095	ADC de micro
16	0–65535	int, 0xFFFF
32	0–4294967295	uint32_t

MSB / LSB: Bit más/menos significativo (el que pesa 128 vs el que pesa 1): el orden importa en protocolos y cables.
0b y 0x: Prefijos de programador: 0b1010 = 10, 0xFF = 255. El compilador también cuenta en binario.

05 · Bases en código

Convertir sin calculadora

Pesos a mano y verificación con el intérprete.

Python en tu navegador. Escribí el binario a mano y que Python te corrija.

def mostrar(n, bits=8):
    b = format(n, f'0{bits}b')
    h = format(n, f'0{bits//4}X')
    pesos = ' '.join(str(2**i) for i in range(bits-1, -1, -1))
    print(f"{n} = {b} = 0x{h}")
    print(f"pesos: {pesos}")
    return b


mostrar(165)
mostrar(13)
mostrar(255)

165 = 10100101 = 0xA5. 13 = 00001101 = 0x0D. ¿Qué número es 0x3C?

A mano y verificar

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


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

06 · Analogía programador

Switches y máscaras

1
Bits = flags.
Permisos Unix 755 = 3 bits × 3: el binario ya gobierna tus archivos.
2
Hex = volcado.
Ver memoria en hex es ver binario legible: cada dígito, un nibble exacto.
3
Pesos = potencias.
128/64/32… como tamaños 1K/1M: potencias de 2 hasta en la sopa.

07 · Exploración

Laboratorio: 8 interruptores

Prendé y apagá bits (o mové el slider): el laboratorio muestra decimal, hex y la suma de pesos.

LABORATORIO 4

Contador binario

165 = 0xA5

Decimal: 165

Binario10100101

Hex0xA5

Suma128+32+4+1

Nibble alto/bajoA / 5

165 = 10100101 = 0xA5.

Preguntas para explorar

Armá 255 solo con botones. ¿Hex? ¿Suma?
¿Qué cambia si apagás solo el MSB de 165? ¿Y solo el LSB?
Buscá 0x3C con el slider. ¿Decimal? ¿Binario?

Ver respuestas sugeridas

0xFF, 128+64+32+16+8+4+2+1: todos prendidos.
MSB: 165−128 = 37 (cambia mucho). LSB: 165−1 = 164 (cambia poco). Peso manda.
60 = 00111100: 32+16+8+4. (Respuesta a la pregunta del código.)

08 · Comprensión

Confusiones frecuentes

«Hex es otro sistema»

Hex ES binario agrupado de a 4: 0xA5 no se calcula, se lee (1010·0101). Otro formato, mismos bits.

«0b10 = 10»

0b10 = 2: el prefijo cambia la base. Leer “10” sin base es como leer sin unidades.

«Con 8 bits alcanza para todo»

255 se queda corto para 1000, para −1 y para 12 bits del ADC: el ancho se elige por rango, no por costumbre.

«El orden de bits da igual»

MSB primero o LSB primero (endianness) cambia todo en serie: acordarlo antes de cablear o programar.

09 · Práctica guiada

Ejercicios de bases

Ejercicio 1: contar hasta 15

Escribí 0–15 en binario de 4 bits a mano. Verificá el 13 y el 10 con a_decimal().

Ver solución razonada

0000…1111: el 13 es 1101 y el 10 es 1010 (0xA). Contar en binario es sumar 1 con acarreo.

Ejercicio 2: matrícula hex

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

Ver solución

31, 128 y 195: 0x80 es el MSB de 8 bits; 0xC3 = 192+3. Direcciones típicas de I2C.

Ejercicio 3: DIP switch

Switch de 8 posiciones en 0x3C. ¿Qué posiciones (1–8, MSB primero) están ON?

Ver solución

3, 4, 5, 6 (00111100): los dos extremos OFF. Leer DIP es leer binario con dedos.

10 · Síntesis

Ideas para recordar

Pesos 128–1; 13 = 1101; 255 = 0xFF.
1 hex = 1 nibble: 0xA5 = 10100101 = 165.
N bits → 0 a 2^N−1.
MSB pesa, LSB ajusta; el orden se acuerda.
0b y 0x: la base siempre explícita.

Bases dominadas. Ahora qué significan: en el próximo tema, representación de información digital.