Convertidor decimal-hex-binario-octal

Si trabajas con redes, Linux, Windows, microcontroladores, SDR o depuración de bajo nivel, te cruzas constantemente con números en distintas bases: decimal en logs, hexadecimal en volcados de memoria, binario en bitmasks y octal en los permisos clásicos de Unix. Este convertidor rápido te permite pegar un valor en casi cualquier formato común (incluyendo 0x, 0b y 0o) y ver al instante las representaciones equivalentes, bits/bytes agrupados y, opcionalmente, una interpretación signed (complemento a dos). Es una herramienta práctica para desarrolladores, sysadmins y entusiastas de la electrónica que necesitan resultados rápidos y listos para copiar al decodificar registros, flags, campos de paquetes o al investigar valores “raros” en firmware y salidas del sistema.

Entender las bases numéricas en el trabajo técnico real

Cuando construyes, depuras u optimizas cualquier cosa técnica —software, firmware, equipos de red, receptores SDR, servidores Linux o incluso interfaces de audio— tarde o temprano aparece el mismo punto de fricción: los números no siempre se muestran en la base “en la que piensas”. Los logs suelen usar decimal, los memory dumps prefieren hexadecimal, las bitmasks son naturalmente binarias y los permisos Unix siguen apareciendo en octal. Un convertidor de bases convierte esa traducción mental constante en una operación de un segundo, y por eso estos tools se usan a diario.

Esta guía explica qué representan realmente decimal, hexadecimal, binario y octal, cómo reconocerlos “en la vida real” y cómo evitar errores comunes —especialmente con valores signed, complemento a dos, ancho en bits (bit width) y endianness.

Decimal vs binario vs hexadecimal vs octal

Decimal

El decimal (base 10) es el sistema cotidiano. Los dígitos van de 0 a 9 y cada posición representa una potencia de 10.

Ejemplo:

255 significa: 2×10² + 5×10¹ + 5×10⁰

En ingeniería, el decimal es típico en UI, métricas, valores de tiempo, límites de configuración y números “humanos” como “1000 Mbps” o “5 ms”.

Binario

El binario (base 2) usa solo 0 y 1. Cada posición representa una potencia de 2.

Ejemplo:

11111111₂ = 1×2⁷ + 1×2⁶ + … + 1×2⁰ = 255

El binario es el idioma nativo de:

• flags y bitmasks

• mapas de registros y periféricos de microcontroladores

• permisos, feature toggles, palabras de estado

• representaciones DSP/SDR (bit depth, formatos de muestra)

Es muy explícito, pero se hace largo rápidamente.

Hexadecimal

El hexadecimal (base 16) usa 0–9 y A–F (o a–f) para 10–15. Cada posición representa una potencia de 16.

Ejemplo:

FF₁₆ = 15×16¹ + 15×16⁰ = 240 + 15 = 255

Hex es popular porque mapea perfecto con binario:

• 1 dígito hex = 4 bits (nibble)

• 2 dígitos hex = 1 byte (8 bits)

Por eso los volcados de memoria, MAC addresses, hextets IPv6, CRCs, hashes y valores de registros suelen aparecer en hex.

Octal

El octal (base 8) usa 0–7. Es menos común hoy, pero sigue siendo muy relevante en sistemas tipo Unix.

Uso clásico:

• permisos de archivos como 755, 644, 600

Cada dígito octal equivale a 3 bits (8 = 2³), así que encaja perfecto con permisos.

Cómo reconocer formatos rápidamente

En sistemas reales, los prefijos ayudan:

• 0xFF → hexadecimal

• 0b1010 → binario

• 0o377 → octal (Python y tools modernos)

• 077 → octal en convenciones legacy (sobre todo estilo C antiguo)

No todo trae prefijos. Muchos dumps muestran hex “a pelo”:

DEADBEEF
FFEE12

Por eso puede ser útil detectar binario “sin prefijo” (10101100 sin 0b), pero es ambiguo: 10101100 también podría ser decimal. Mejor como opción, no como comportamiento por defecto.

Por qué agrupar bits y bytes

Las cadenas binarias largas son difíciles de leer. La agrupación mejora muchísimo la legibilidad:

• agrupación por nibble (4 bits):
  10101100 → 1010 1100

• agrupación por byte en hex (2 dígitos):
  DEADBEEF → DE AD BE EF

Esto importa al depurar:

• cabeceras de protocolos (campos alineados a bytes o nibbles)

• registros de microcontroladores (bit fields)

• estructuras empaquetadas y formatos binarios

Un buen convertidor lo muestra automáticamente porque reduce errores al escanear valores.

Ancho en bits: la pieza que falta en muchas conversiones

Uno de los mayores focos de confusión es que los enteros no son “infinitos”: viven en un número fijo de bits (8, 16, 32, 64…).

Ejemplo con 0xFF:

• unsigned 8-bit: 0xFF = 255

• signed 8-bit: 0xFF = -1 (complemento a dos)

• unsigned 16-bit: 0x00FF = 255

• signed 16-bit: sigue siendo 255 (bit de signo = 0)

Por eso elegir el ancho correcto es clave al interpretar valores de:

• registros hardware (a menudo 8/16/32 bits)

• paquetes de red (campos de tamaño fijo)

• lecturas signed de sensores

• structs de firmware y mensajes empaquetados

Al seleccionar N bits, un convertidor serio aplica wrap-around modulo 2^N, igual que los enteros de máquina.

Signed vs unsigned y complemento a dos

Idea central

Un patrón de bits son bits. Signed o unsigned depende de la interpretación.

• unsigned: 0 a 2^N − 1

• signed (complemento a dos): −2^(N−1) a 2^(N−1) − 1

El complemento a dos es prácticamente universal porque simplifica la aritmética.

Regla mental rápida

Para N bits signed:

• MSB = 0 → positivo

• MSB = 1 → negativo

Ejemplo (8 bits):

• 0b01111111 = 127

• 0b10000000 = -128

• 0b11111111 = -1

Convertir complemento a dos “a mano”

Para interpretar como signed:

• Si MSB = 0, el valor es igual que unsigned.

• Si MSB = 1, resta 2^N al valor unsigned.

Ejemplo:

0xFF (8 bits) = 255 unsigned
signed: 255 − 256 = −1

Por eso un toggle de “signed interpretation” en el convertidor es tan útil.

Ejemplos prácticos reales

Ejemplo 1: flags en un registro de estado

Registro = 0x2D y datasheet:

• Bit 0: READY

• Bit 2: ERROR

• Bit 3: TX_ACTIVE

• Bit 5: LOW_BAT

0x2D → binario: 0010 1101

Lectura:

• bit 0 = 1 (READY)

• bit 2 = 1 (ERROR)

• bit 3 = 1 (TX_ACTIVE)

• bit 5 = 1 (LOW_BAT)

Ejemplo 2: permisos Unix en octal

755:

• owner 7 → rwx

• group 5 → r-x

• others 5 → r-x

Cada dígito octal son 3 bits:

• 7 → 111

• 5 → 101

• 4 → 100

Así se entiende fácil por qué 644 es típico en archivos:

• 6 = 110 → rw-

• 4 = 100 → r–

• 4 = 100 → r–

Ejemplo 3: números negativos de sensores

Un sensor puede dar un valor signed 16-bit:

0xFF9C

unsigned: 65436 (no tiene sentido como temperatura)
signed: 65436 − 65536 = −100

Si la unidad es 0,01 °C, entonces −100 = −1,00 °C. Un convertidor con vista “16-bit signed” te ahorra errores.

Por qué NOT, shifts y AND/OR/XOR ayudan en un convertidor

Operaciones bitwise aparecen en todas partes:

AND

Para limpiar bits o probar flags:

• value & mask
  Ejemplo: leer los 8 bits bajos: x & 0xFF

OR

Para poner bits a 1:

• value | mask

XOR

Para alternar bits o comparar patrones:

• value ^ mask

NOT

NOT invierte cada bit en un ancho fijo.

En 8 bits:

• NOT 0x00 → 0xFF

• NOT 0x0F → 0xF0

Detalle importante: NOT solo tiene sentido con un ancho definido. Sin ancho, se vuelve ambiguo.

Shifts

Se usan para:

• escalar por potencias de dos

• empaquetar/desempaquetar campos

• construir máscaras

Extracción de campo típica:

• (value >> 12) & 0xF

Endianness: por qué el orden de bytes importa

Endianness describe el orden de bytes en valores multi-byte.

• big-endian: byte más significativo primero

• little-endian: byte menos significativo primero

Para 0x12345678:

• big-endian: 12 34 56 78

• little-endian: 78 56 34 12

Importa porque:

• muchas CPU guardan en little-endian (x86)

• muchos protocolos definen big-endian (network byte order)

Un convertidor que muestre ambas vistas y permita swap de endianness ayuda mucho en capturas, dumps, archivos binarios y bugs de serialización.

Errores comunes y cómo evitarlos

• asumir que hex implica unsigned: hex es solo formato

• olvidar el ancho al usar NOT o shifts: el resultado depende del número de bits

• mezclar ASCII, bytes y números: ASCII es un encoding, no una regla universal

• pensar que los números con cero inicial siempre son octales: solo en ciertos contextos legacy

• asumir que “101010” es binario: puede ser decimal

Dónde aparece la conversión de bases en el día a día

La usarás constantemente si:

• lees logs de kernel o eventos Windows con flags en hex

• depuras campos de paquetes (Wireshark / raw)

• trabajas con registros de microcontroladores (GPIO, UART, SPI)

• haces reverse engineering de firmware o formatos binarios

• calculas subnet masks, bitmasks y feature flags

• ajustas pipelines SDR/DSP (bit depth, formatos)

• interpretas bytes MIDI o palabras de estado de audio

• verificas CRCs, hashes y checksums

Consejos para sacarle el máximo al convertidor

• usa prefijos (0x/0b/0o) cuando puedas

• selecciona ancho (8/16/32/64) para hardware y protocolos

• usa agrupación (nibbles/bytes) para leer más rápido

• valida máscaras y extracciones con AND/shift/XOR

• si hay sincronización por URL, comparte un link para depuración reproducible

Las imágenes utilizadas en este artículo son generadas por IA...

Este artículo puede contener enlaces de afiliado...