Electrónica Digital · Tema 5

Representar información digital

Mismo byte, cuatro lecturas: 0x25 es 37, +37, 25 o ‘%’. El convenio manda, los bits obedecen.

01 · Punto de partida

Bits sin convenio no dicen nada

¿0xA5 es 165 o −91? ¿0x25 es 37 o 25? Sin convenio no hay respuesta: sin signo, complemento a dos, BCD y ASCII leen los mismos bits de formas distintas. Como en programación: uint8_t vs int8_t vs char.

  • ¿Cómo se representan negativos?
  • ¿Cómo se guardan decimales para display?
  • ¿Cómo viajan las letras?
  • ¿Qué pasa si mezclás convenios?

02 · Complemento a dos

Negar es invertir + 1

Rango −128…127: el MSB pesa −128. −91 se guarda como ~0x5B+1… al revés: 91 = 0x5B, invertido 0xA4, +1 = 0xA5. Magia útil: la suma funciona igual con y sin signo (5 + (−3) = 2 con el mismo circuito).

91 = 0x5B → invertir →0xA4 → +1 →−91 = 0xA5

03 · BCD

Decimales para display

Un dígito decimal por nibble: 25 = 0x25 (0010·0101). Relojes y multímetros lo aman (cada dígito va directo al display); las cuentas lo odian (A–F son inválidos, sumar pide corrección +6). 0xA5 en BCD es inválido (nibble A).

Binario puro

Compacto para calcular

25 = 0x19: suma directa, display difícil (dividir por 10).

BCD

Listo para mostrar

25 = 0x25: display directo, suma con ajuste. RTC y relojes.

04 · ASCII

Letras por cable

Dígitos
‘0’–‘9’ = 0x30–0x39: restar 0x30 convierte a valor. El UART manda texto, no números.
Letras
‘A’ = 0x41, ‘a’ = 0x61: mayúsculas y minúsculas difieren en 0x20 (un bit cambia el caso).
Control
0x00–0x1F: salto de línea 0x0A, retorno 0x0D. 7 bits + resto para extensiones.
El byte camaleón
0x25 = 37 (U) = +37 (S) = 25 (BCD) = ‘%’ (ASCII). Cuatro respuestas, un byte.

05 · Convenios en código

Cuatro lecturas de un byte

Intérprete de convenios más resta por suma en Ca2.

Python en tu navegador. Pasale tu byte y mirá sus personalidades.

def lecturas(b):
    u = b
    s = b - 256 if b >= 128 else b
    hi, lo = b >> 4, b & 0xF
    bcd = f"{hi}{lo}" if hi <= 9 and lo <= 9 else "invalido"
    asc = chr(b) if b < 128 else "no-ASCII"
    print(f"0x{b:02X}: U={u} S={s:+d} BCD={bcd} ASCII={asc!r}")
    return u, s


for b in (0x25, 0xA5, 0xFF, 0x41):
    lecturas(b)

0x25 → 37/+37/“25”/‘%’. 0xA5 → 165/−91/inválido/no-ASCII. ¿Qué da 0x00?

Restar sumando

def negar8(x):
    return (~x + 1) & 0xFF


a, b = 5, 3
r = (a + negar8(b)) & 0xFF
print(f"5-3 = 5+{negar8(b):#04x} = {r}")
print(f"-91 en 8 bits: {negar8(91):#04x}")

06 · Analogía programador

Tipos y encodings

  1. 1
    Ca2 = int8_t.

    Mismo byte que uint8_t, otra lectura: el tipo vive en tu cabeza (y en tu suma).

  2. 2
    BCD = formato display.

    Como guardar “25” string para mostrarlo: cómodo de leer, incómodo de operar.

  3. 3
    ASCII = encoding.

    Bytes ↔ texto según tabla: como UTF-8, pero de 1963 y sin emojis.

07 · Exploración

Laboratorio: el camaleón

Mové el byte de 0 a 255: el laboratorio lo lee en los cuatro convenios a la vez.

LABORATORIO 5

Camaleón

0x25 · cuatro lecturas

Sin signo37
Con signo+37
BCD25 ✓
ASCII‘%’

0x25: 37 / +37 / BCD 25 / ‘%’.

Preguntas para explorar

  1. Llevá a 0xA5. ¿Cuatro lecturas? ¿Por qué BCD y ASCII fallan?
  2. Buscá 0x41. ¿Letra? ¿Y 0x61? ¿Diferencia?
  3. ¿En qué rango U y S coinciden? ¿Por qué?
Ver respuestas sugeridas
  1. 165 / −91 / inválido (A) / no-ASCII (>127): dos convenios numéricos, dos que no aplican.
  2. ‘A’ y ‘a’: difieren 0x20 (un bit). Cambiar caso = XOR 0x20.
  3. 0–127: el MSB en 0, Ca2 no resta nada. A partir de 128 divergen.

08 · Comprensión

Confusiones frecuentes

«El bit alto es el signo»

Eso es signo-magnitud (casi no se usa): en Ca2 el MSB pesa −128 y la suma funciona sin casos especiales.

«BCD 0x25 = 37»

BCD 0x25 se lee “25”, no 37: son 37 unidades binarias pero 25 dígitos. Mezclar lecturas = bug.

«ASCII son 8 bits»

ASCII son 7 (0–127): el octavo era paridad o extensiones (Latin-1). ‘A’ cabe en 7 bits.

«Ca2 desperdicia un valor»

Al contrario: un solo cero y rango asimétrico útil (−128). El que desperdicia es signo-magnitud (±0).

09 · Práctica guiada

Ejercicios de convenios

Ejercicio 1: negar a mano

Representá −1, −37 y −128 en 8 bits. Verificá con negar8().

Ver solución razonada

0xFF, 0xDB y 0x80: 37 = 0x25 → ~0xDA +1 = 0xDB. −128 no tiene positivo (límite asimétrico).

Ejercicio 2: RTC en BCD

Reloj marca 0x23:59 (BCD). ¿Hora decimal? ¿Y 0x23 en binario puro?

Ver solución

23:59 ✓. En binario 0x23 = 35: leer un RTC en hex puro da cualquier hora menos la real.

Ejercicio 3: UART que miente

Llega 0x41 por serie. ¿Valor numérico? ¿Letra? ¿Cómo convertir ‘0’–‘9’ a valor?

Ver solución

65 / ‘A’. Dígitos: restar 0x30 (‘0’ = 0x30). Error clásico: usar el ASCII como número.

10 · Síntesis

Ideas para recordar

  • Ca2: −x = ~x+1; −128…127; suma única.
  • BCD: dígito por nibble; A–F inválidos.
  • ASCII: ‘0’ = 0x30, ‘A’ = 0x41, caso = bit 0x20.
  • 0x25 = 37/+37/25/‘%’: el convenio manda.
  • Mezclar lecturas = bug silencioso.

Convenios dominados. Ahora el lenguaje de las decisiones: en el próximo tema, tablas de verdad.