Guía de resolución — Examen de Sistemas Digitales II, Junio 2026 (10-06-2026)

Guía modelo de resolución, para preparar la convocatoria de noviembre-diciembre de 2026. El examen tiene 3 problemas: mapa de memoria (3,5 p), diagrama ASM + VHDL (3,5 p) y PicoBlaze (3 p).

Importante: el profesor no puntúa ejercicios mal planteados. Escribe siempre el planteamiento (2-3 frases) antes de desarrollar, justifica cada elección y deja verificable el resultado final (tablas, direcciones, código).


Problema 1 — Mapa de memoria (3,5 puntos)

Enunciado íntegro del Problema 1 (mapa de memoria). El P1 no lleva ninguna figura: todo lo necesario está en el texto.
Enunciado íntegro del Problema 1 (mapa de memoria). El P1 no lleva ninguna figura: todo lo necesario está en el texto.

Planteamiento. El procesador direcciona 16K posiciones de 16 bits, es decir 16384 palabras con 14 líneas de dirección (A13–A0). Hay que colocar seis bloques (ROM 4K, EPROM, RAM, E/S-1 256, hueco 768, E/S-2 256) sin solapamiento, construir cada bloque con expansiones de palabras y de bits a partir de los CI disponibles, y generar las señales de habilitación (CS activa a nivel BAJO en memorias; CS1 y CS2 activas a nivel ALTO en E/S) decodificando las líneas altas de dirección.

Direcciones en hexadecimal con 14 bits: se escriben como 4 dígitos hex (equivalen a 16 bits con A15=A14=0, que no existen).

Datos que fija el enunciado y decisiones de diseño. Fija el enunciado: el espacio 16K×16 (16 384 posiciones de 16 bits → A13…A0), la ROM de 4K desde 0, los módulos E/S-1 y E/S-2 de 256 posiciones con hueco libre de 768 entre ellos, y los CIs disponibles (ROM 4K×8, EPROM 1K×16, RAM 4K×4, dos módulos de E/S). También la polaridad: CS de memorias activa a nivel BAJO; CS1 y CS2 de E/S activas a nivel ALTO, que se unen a la MISMA salida de decodificación (el AND interno del módulo queda satisfecho). No lo fija el enunciado: el tamaño de los bloques EPROM y RAM —el P1 no tiene figura, es 100 % textual—, que es por tanto decisión propia justificada (rango derivado en el apartado a). La guía desarrolla EPROM 4K + RAM 4K, opción redonda y coherente con los CIs (deja 2816 posiciones libres); con otro reparto válido solo cambian las direcciones y las señales de CS, no el método.

a) Demostrar que caben + nº de CI por bloque (0,5 p)

El enunciado fija ROM 4K, E/S 256, hueco 768 y E/S 256, pero no da el tamaño de EPROM y RAM: hay que elegirlo y justificarlo a partir de los CIs. En el examen no se memoriza un tamaño: se deriva el rango.

La guía desarrolla el reparto EPROM 4K + RAM 4K para fijar mapa, tablas y VHDL; en el apartado c) se desarrolla la alternativa más relevante (EPROM 2K + RAM 8K).

Suma de posiciones necesarias (para el reparto desarrollado):

Bloque Posiciones
ROM 4K 4096
EPROM (elegido 4K; admisible 1K–6K con RAM 4K) 4096
RAM (elegido 4K; bloque mínimo ×16; admisible también 8K) 4096
E/S-1 256
Hueco 768
E/S-2 256
Total 13 568

13 568 ≤ 16 384 → caben, y sobran 2 816 posiciones. Nótese que el hueco de 768 es justo 3 sub-bloques de 256: encaja en la región 0x3000–0x3FFF dividida en 16 sub-bloques de 256 seleccionados por A11…A8.

Nº mínimo de CI por bloque (expansión de palabras × expansión de bits):

Bloque Tamaño bloque CI disponible Palabras Bits Nº CI
ROM 4K×16 ROM 4K×8 4096/4096 = 1 16/8 = 2 2 (en paralelo)
EPROM 4K×16 EPROM 1K×16 4096/1024 = 4 16/16 = 1 4 (en cascada)
RAM 4K×16 RAM 4K×4 4096/4096 = 1 16/4 = 4 4 (en paralelo)
E/S-1 / E/S-2 256 c/u módulos hechos — — 1+1

Total: 10 CI de memoria + 2 módulos de E/S.

📚 Teoría: Tema 1, pág. 53 del PDF «Tema 1 SD-II_20200206.pdf» — organización de memorias: palabras de m bits. 📚 Teoría: Tema 1, pág. 54 del PDF «Tema 1 SD-II_20200206.pdf» — tipos de ROM: programables, PROM y EPROM. 📚 Teoría: Tema 5, pág. 32 del PDF «Tema 5 SD-II_20230215.pdf» — capacidad direccionable según el bus de direcciones.

b) Mapa de memoria del sistema (0,75 p)

Problema 1 · Mapa de memoria interactivo (16K posiciones, bus de datos de 16 bits)

Espacio 0000H–3FFFH (14 líneas de dirección A13–A0; A15 y A14 no existen) · orden ROM → EPROM → RAM → E/S-1 → hueco → E/S-2 → libre · memorias: CS̅ activo a nivel BAJO · E/S: CS1 y CS2 activos a nivel ALTO

⚠ Los tamaños EPROM/RAM no los fija el enunciado: hay varios repartos válidos (RAM 4K u 8K; con RAM 4K, EPROM de 1K a 6K). El mapa que se explora aquí es una solución válida — la que desarrolla la guía (EPROM 4K + RAM 4K). Cambia solo las direcciones y las señales de CS, no el método.

ROM-0: 4K×8 → D7–D0 (comparte CS_ROM y A11–A0) ROM-0 · 4K×8 → D7–D0 ROM-1: 4K×8 → D15–D8 (comparte CS_ROM y A11–A0) ROM-1 · 4K×8 → D15–D8 EPROM-0: 1K×16 · 1000H–13FFH · A13A12A11A10=0100 EP-0 1K×16 EPROM-1: 1K×16 · 1400H–17FFH · A13A12A11A10=0101 EP-1 1K×16 EPROM-2: 1K×16 · 1800H–1BFFH · A13A12A11A10=0110 EP-2 1K×16 EPROM-3: 1K×16 · 1C00H–1FFFH · A13A12A11A10=0111 EP-3 1K×16 RAM-0: 4K×4 → D3–D0 RAM-0 · 4K×4 → D3–D0 RAM-1: 4K×4 → D7–D4 RAM-1 · 4K×4 → D7–D4 RAM-2: 4K×4 → D11–D8 RAM-2 · 4K×4 → D11–D8 RAM-3: 4K×4 → D15–D12 RAM-3 · 4K×4 → D15–D12 ROM 4K×16 · 2 CI 4K×8 (paralelo) EPROM 4K×16 · 4 CI 1K×16 (cascada) RAM 4K×16 · 4 CI 4K×4 (paralelo) hueco 768 E/S-1 E/S-2 libre 2816 · sin decodificar 3×256 0000 0FFF 1000 1FFF 2000 2FFF 3000 30FF 3100 33FF 3400 34FF 3FFF
Pulsa Enter o Decodificar · el marcador naranja señala la posición sobre el mapa a escala

Mini-examen · rellena con rango hex (4 dígitos) o nº de CI — pistas basadas en los «errores típicos — P1» de la guía

Aciertos: —

Colocación en el orden pedido, todas las bases alineadas en potencias de 2:

0x0000 ┌────────────────────────────┐
       │ ROM   4K (2 × ROM 4K×8)    │
0x0FFF ├────────────────────────────┤
       │ EPROM 4K (4 × EPROM 1K×16) │
0x1FFF ├────────────────────────────┤
       │ RAM   4K (4 × RAM 4K×4)    │
0x2FFF ├────────────────────────────┤
       │ E/S-1 256                  │
0x30FF ├────────────────────────────┤
       │ Hueco 768 (= 3 × 256)      │
0x33FF ├────────────────────────────┤
       │ E/S-2 256                  │
0x34FF ├────────────────────────────┤
       │ libre 2816                 │
0x3FFF └────────────────────────────┘

📚 Teoría: Tema 5, pág. 33 del PDF «Tema 5 SD-II_20230215.pdf» — ejemplo de diseño de mapa: RAM, ROM, E/S.

c) Tabla de direcciones inicial y final (0,75 p)

Binario son las 14 líneas A13…A0 (agrupadas 2+4+4+4 por legibilidad).

Por bloque:

Bloque Inicial (binario A13..A0) Final (binario A13..A0) Inicial hex Final hex
ROM 00 0000 0000 0000 00 1111 1111 1111 0000H 0FFFH
EPROM 01 0000 0000 0000 01 1111 1111 1111 1000H 1FFFH
RAM 10 0000 0000 0000 10 1111 1111 1111 2000H 2FFFH
E/S-1 11 0000 0000 0000 11 0000 1111 1111 3000H 30FFH
Hueco 11 0001 0000 0000 11 0011 1111 1111 3100H 33FFH
E/S-2 11 0100 0000 0000 11 0100 1111 1111 3400H 34FFH
(libre) 11 0101 0000 0000 11 1111 1111 1111 3500H 3FFFH

Por circuito integrado (nivel CI: lo que exige "cada circuito"):

CI Seleccionado por Inicial hex Final hex
ROM-0 (D7–D0) y ROM-1 (D15–D8) A13A12 = 00 0000H 0FFFH
EPROM-0 A13A12A11A10 = 0100 1000H 13FFH
EPROM-1 0101 1400H 17FFH
EPROM-2 0110 1800H 1BFFH
EPROM-3 0111 1C00H 1FFFH
RAM-0..RAM-3 (todas) A13A12 = 10 2000H 2FFFH
E/S-1 (CS1,CS2) A13..A8 = 110000 3000H 30FFH
E/S-2 (CS1,CS2) A13..A8 = 110100 3400H 34FFH

Reparto alternativo, igualmente válido: EPROM 2K + RAM 8K. Mismos bloques y orden; solo cambian direcciones y CS (EPROM: 2 CI de 1K×16, elegidos por A10; RAM: dos filas de 4 CI 4K×4 en paralelo, expansión de palabras ×2 = 8 CI):

Bloque Inicial hex Final hex Posiciones
ROM 0000H 0FFFH 4096
EPROM 1000H 17FFH 2048
RAM 1800H 37FFH 8192
E/S-1 3800H 38FFH 256
Hueco 3900H 3BFFH 768
E/S-2 3C00H 3CFFH 256
(libre) 3D00H 3FFFH 768

Suma: 15 616 ≤ 16 384 (libres 768), sin solapes, orden del enunciado respetado (comprobado). Aviso de decodificación: ROM, EPROM, E/S y hueco quedan alineados, pero la RAM de 8K no puede alinearse a su tamaño en este orden (un bloque de 8K solo empezaría limpio en 0000H o 2000H: la base 0000H choca con la ROM y la 2000H se comería el final del espacio y no dejaría sitio para E/S-1 + hueco + E/S-2). Su CS es entonces la suma de las cuatro combinaciones de A13A12A11 011, 100, 101 y 110, que cubren exactamente 1800H–37FFH: perfectamente asumible para el decodificador programable del apartado f), aunque menos limpia que el reparto principal — que sí alinea todos los bloques a potencias de 2, y es la razón de desarrollarlo como solución de referencia.

📚 Teoría: Tema 5, pág. 40 del PDF «Tema 5 SD-II_20230215.pdf» — señales de habilitación CE/EN de cada integrado.

d) Líneas de decodificación y porqué (0,25 p)

Un bloque de tamaño 2ⁿ consume internamente las n líneas bajas; la decodificación usa las que quedan por encima:

Justificación de la elección: los bloques grandes (4K) se colocan en las bases naturales de A13A12 y así solo se necesitan 2 líneas para ellos; la última combinación (11) se reserva a la zona fina de E/S+reserva, que es la única que requiere decodificación completa de A11…A8. Todo queda alineado en potencias de 2, lo que simplifica la decodificación y evita solapamientos.

📚 Teoría: Tema 5, pág. 34–35 del PDF «Tema 5 SD-II_20230215.pdf» — condiciones de habilitación y decodificación reducida. 📚 Teoría: Tema 1, pág. 3–5 del PDF «Tema 1 SD-II_20200206.pdf» — decodificador completo: n entradas y 2ⁿ salidas.

e) Diagrama lógico completo (1 p) — descripción detallada

CPU (KCPSM6, bus de datos de 16 bits) A13–A0 (salida) · D15–D0 (bidireccional) · R/W‾ (control) A D R/W‾ DECODIFICADOR (módulo VHDL del apartado f) Entrada: A13…A8 (partes altas del bus de direcciones) CS̅_ROM = 0 si A13A12 = 00 → 0000H–0FFFH CS̅_EPROM0..3 = 0: A13A12A11A10 = 0100/0101/0110/0111 (CI k: 1000H + 400H·k) CS̅_RAM = 0 si A13A12 = 10 → 2000H–2FFFH CS_ES1 = 1 si A13…A8 = 110000 → 3000H–30FFH CS_ES2 = 1 si A13…A8 = 110100 → 3400H–34FFH (hueco 3100H–33FFH sin CS) ROM 4K×16 · 0000H–0FFFH (expansión de bits: 2 CI) ROM-0 4K×8 D7–D0 CS̅_ROM (común) ROM-1 4K×8 D15–D8 CS̅_ROM (común) EPROM 4K×16 · 1000H–1FFFH (expansión de palabras: 4 CI) A11,A10 eligen el CI desde el decodificador; A9–A0 van a las cuatro EPROM-0 1K×16 CS̅_EPROM0 1000H–13FFH EPROM-1 1K×16 CS̅_EPROM1 1400H–17FFH EPROM-2 1K×16 CS̅_EPROM2 1800H–1BFFH EPROM-3 1K×16 CS̅_EPROM3 1C00H–1FFFH RAM 4K×16 · 2000H–2FFFH RAM-0 (4K×4) D3–D0 RAM-1 (4K×4) D7–D4 RAM-2 (4K×4) D11–D8 RAM-3 (4K×4) D15–D12 E/S-1 · 3000H–30FFH CS1 = CS2 = CS_ES1 (ALTO) R/W‾ + strobes del módulo Datos: D7–D0 A7–A0 E/S-2 · 3400H–34FFH CS1 = CS2 = CS_ES2 (ALTO) R/W‾ + strobes del módulo Datos: D7–D0 A7–A0 3100H–33FFH y 3500H–3FFFH: sin señal CS (huecos libres) A13–A0 (14) A13…A8 A11–A0 A9–A0 A11–A0 (12) A7–A0 A7–A0 D15–D0 (16) D15–D0 D15–D0 D15–D0 D7–D0 | D15–D8 CS̅_ROM CS̅_EPROM0..3 CS̅_RAM CS_ES1 (= CS1 = CS2, ALTO) CS_ES2 (= CS1 = CS2, ALTO) R/W‾ OE OE · WE‾ Notas: barra doble = bus (nº de líneas); puntos = unión de líneas; trazos discontinuos = R/W‾ (OE en todas las memorias, WE‾ solo en RAM). CS̅ de las memorias se activa a nivel BAJO; CS1 y CS2 de los módulos E/S se activan a nivel ALTO y reciben la misma señal.

Figura: diagrama lógico completo de la solución de ejemplo (mapa de los apartados b/c y decodificación de los apartados d/f).

Dibujar lo siguiente (todo conectado, con nombres de señal):

  1. CPU (bloque): bus de direcciones A13…A0 (14 líneas), bus de datos de 16 bits D15…D0, señales de control R/W̄.
  2. Partición del bus de direcciones: - A11…A0 → direcciones de las 2 ROM y de las 4 RAM. - A9…A0 → direcciones de las 4 EPROM (A11,A10 van a la decodificación). - A7…A0 → direcciones de los módulos E/S-1 y E/S-2.
  3. Bus de datos: ROM-0 → D7–D0, ROM-1 → D15–D8; cada EPROM → D15–D0; RAM-0 → D3–D0, RAM-1 → D7–D4, RAM-2 → D11–D8, RAM-3 → D15–D12; E/S ↔ D15…D0 (E/S usan 8 bits: D7–D0).
  4. Bloque decodificador (PLA/dispositivo programable o módulo VHDL del apartado f): entradas A13…A8; salidas: - CS_ROM (BAJO) → al CS de las 2 ROM. - CS_EPROM0..3 (BAJO) → al CS de cada EPROM. - CS_RAM (BAJO) → al CS de las 4 RAM. - CS_ES1 (ALTO) → a CS1 y CS2 del módulo E/S-1. - CS_ES2 (ALTO) → a CS1 y CS2 del módulo E/S-2.
  5. Control de lectura/escritura: R/W̄ de la CPU → OE (y WE̅ en la RAM) de las memorias habilitadas; en E/S, las señales de lectura/escritura del bus de control con los strobes del módulo (dibujar el AND CS·read/write si el módulo lo pide).
  6. Todas las líneas sin usar (A15, A14 no existen; A9, A8 en ROM/RAM van directas; dejar claro qué línea va a dónde).

📚 Teoría: Tema 1, pág. 45–47 del PDF «Tema 1 SD-II_20200206.pdf» — matrices lógicas programables: PLA.

f) Módulo VHDL de decodificación para FPGA (0,75 p)

Analizado con GHDL 4.1.0 (--std=08 estricto — este módulo solo usa comparaciones de patrones, no necesita STD_LOGIC_UNSIGNED) y verificado con un barrido exhaustivo de las 16.384 direcciones (0000H–3FFFH) con las expectativas generadas por rangos desde la tabla del apartado b): 16.384 comprobaciones, 0 fallos, 0 solapes — en cada dirección activa exactamente una señal: ROM = 4.096 direcciones, cada EPROM 1.024 (4.096 en total), RAM = 4.096, E/S-1 = 256, E/S-2 = 256; en los huecos 3100H–33FFH y 3500H–3FFFH (3.584 direcciones) ninguna CS activa, y fuera de 3000H–30FFH y 3400H–34FFH los dos when A = … de E/S mantienen '0'. Scripts: decodificador.vhd y tb_decodificador.vhd en ~/.hermes/cache/scratch/vhdl-jun26/:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity Decodificador is
    port (
        A        : in  std_logic_vector(13 downto 8); -- lineas altas de direccion
        CS_ROM   : out std_logic;                     -- activa a nivel BAJO
        CS_EPROM : out std_logic_vector(3 downto 0);  -- una por EPROM, BAJO
        CS_RAM   : out std_logic;                     -- activa a nivel BAJO
        CS_ES1   : out std_logic;                     -- activa a nivel ALTO (CS1 y CS2)
        CS_ES2   : out std_logic                      -- activa a nivel ALTO (CS1 y CS2)
    );
end entity Decodificador;

architecture Behaviour of Decodificador is
begin
    -- ROM: A13 A12 = 0 0  (0000H - 0FFFH)
    CS_ROM <= '0' when A(13 downto 12) = "00" else '1';

    -- EPROM: A13 A12 = 0 1 y A11 A10 elige el CI de 1K (1000H - 1FFFH)
    with A(13 downto 10) select CS_EPROM <=
        "1110" when "0100",   -- EPROM0: 1000H - 13FFH
        "1101" when "0101",   -- EPROM1: 1400H - 17FFH
        "1011" when "0110",   -- EPROM2: 1800H - 1BFFH
        "0111" when "0111",   -- EPROM3: 1C00H - 1FFFH
        "1111" when others;

    -- RAM: A13 A12 = 1 0  (2000H - 2FFFH)
    CS_RAM <= '0' when A(13 downto 12) = "10" else '1';

    -- E/S-1: A13..A8 = 1 1 0 0 0 0  (3000H - 30FFH)
    CS_ES1 <= '1' when A = "110000" else '0';

    -- E/S-2: A13..A8 = 1 1 0 1 0 0  (3400H - 34FFH)
    CS_ES2 <= '1' when A = "110100" else '0';
end architecture Behaviour;

📚 Teoría: Tema 1, pág. 33–34 del PDF «Tema 1 SD-II_20200206.pdf» — decodificador 3–8 en VHDL, con enable. 📚 Teoría: Tema 5, pág. 36–37 del PDF «Tema 5 SD-II_20230215.pdf» — VHDL de la decodificación del mapa de memoria. 📚 Teoría: Tema 1, pág. 23 del PDF «Tema 1 SD-II_20200206.pdf» — dispositivos programables: CPLD y FPGA.

Errores típicos — P1

Esquema-resumen de la metodología

  1. Extraer buses y espacio del enunciado — nº de posiciones y ancho de palabra fijan las líneas de dirección (16K×16 → A13–A0); todas las direcciones en hex de 4 dígitos y sin usar A14/A15, que no existen.
  2. Colocar primero los bloques de tamaño fijo — ROM 4K en 0000H y la zona de E/S (E/S-1 256, hueco 768 = 3×256, E/S-2 256) con bases alineadas en potencias de 2; lo fijo deja el hueco donde irán EPROM y RAM.
  3. Derivar el rango admisible de lo que el enunciado no fija — a las 11 008 posiciones libres se ajustan RAM (4K u 8K, múltiplos de sus CIs 4K×4) y EPROM (1K–6K con RAM 4K; 1K–2K con RAM 8K); se elige un reparto concreto y se justifica con la suma.
  4. Comprobar alineación y holgura — cada bloque de 2ⁿ con base múltiplo de su tamaño (uno desalineado obliga a una CS que es suma de varias combinaciones) y total de posiciones ≤ 16 384.
  5. Fijar qué líneas decodifican cada bloque — un bloque de 2ⁿ consume internamente las n líneas bajas y se selecciona con las de encima: bloques de 4K → A13A12; cada EPROM de 1K, además A11A10; E/S de 256 → A13…A8.
  6. Escribir las ecuaciones CS con la polaridad del enunciado — memorias CS̅ activas a nivel BAJO; E/S CS1 y CS2 activas a nivel ALTO y unidas a la misma salida de decodificación; los huecos libres simplemente no se decodifican.
  7. Montar cada bloque con los CIs disponibles — expansión de bits con CIs en paralelo aportando trozos del bus de datos (2 ROM 4K×8, 4 RAM 4K×4) y expansión de palabras en cascada ocupando sub-rangos (4 EPROM 1K×16); en paralelo comparten direcciones y CS.
  8. Dibujar el diagrama lógico completo — CPU, buses con nº de líneas, partición de direcciones por bloque, datos por CI, decodificador con todas las CS y R/W‾ (OE en todas las memorias, WE‾ solo en RAM).
  9. Trasladar la decodificación a VHDL y simularla — una expresión o with ... select por CS sobre A13…A8; la simulación confirma que cada CS activa exactamente en su rango y que en los huecos no activa ninguna.
  10. Barrer todo el espacio de direcciones (0000H–3FFFH) — en cada dirección debe activar una sola CS, o ninguna en los huecos: sin solapes y con las fronteras exactas de la tabla.

Idea transversal: el mapa solo vale si se alinea cada bloque de 2ⁿ sobre múltiplo de su tamaño y se comprueba barriendo todo el espacio de direcciones en busca de solapes y fronteras, no solo direcciones de ejemplo.


Problema 2 — Trampilla de tolva: ASM + VHDL (3,5 puntos)

Enunciado del Problema 2, primera parte: incluye la figura de la trampilla (cilindro a la izquierda; Z = totalmente extendido = cerrada; Y = totalmente recogido = abierta).
Enunciado del Problema 2, primera parte: incluye la figura de la trampilla (cilindro a la izquierda; Z = totalmente extendido = cerrada; Y = totalmente recogido = abierta).
Enunciado del Problema 2, continuación (viene de la página anterior del examen).
Enunciado del Problema 2, continuación (viene de la página anterior del examen).

Planteamiento. La trampilla es una máquina de estados con dos posiciones límite (fijadas por la figura: Z = extendido = cerrada, Y = recogido = abierta; la trampilla se mete en el cuello de la tolva, que está a la derecha del cilindro), dos pulsadores (A abre, C cierra) y un cilindro (I abre, D cierra). Las esperas de 5, 6 y 3 segundos empiezan al SOLTAR el pulsador, y los finales de carrera detienen el motor automáticamente. Los LEDs indican posición: rojo = totalmente cerrada, verde = totalmente abierta.

Datos que fijan el enunciado y la figura. En la figura el cilindro está a la IZQUIERDA y el vástago/trampilla sale hacia la DERECHA metiéndose en el cuello de la tolva, con el dibujo en posición CERRADA: por eso Z (todo extendido) = CERRADA e Y (todo recogido) = ABIERTA. I abre y D cierran: conservan su papel, NO se permutan (la geometría invierte el significado de los finales de carrera, no el del cilindro). V = led VERDE (abierta) y R = led ROJO (cerrada) según el panel de la figura. Los pulsadores A y C nunca se accionan a la vez, y los finales de carrera Y y Z no pueden estar activos simultáneamente (lo fija el enunciado).

a) Cálculos previos con reloj de 25 MHz (0,25 p)

📚 Teoría: Tema 2, pág. 55 del PDF «Tema 2 SD-II_20200317.pdf» — contador: secuencia predefinida de estados. 📚 Teoría: Tema 2, pág. 57–58 del PDF «Tema 2 SD-II_20200317.pdf» — asociación de contadores: módulo mayor. 📚 Teoría: Tema 2, pág. 59 del PDF «Tema 2 SD-II_20200317.pdf» — división de frecuencia: pre-escala del reloj.

b) Diagrama ASM y bloques obtenidos (2 p)

Problema 2 · ASM de control del vástago (esquema de estados de Mealy)

Y = sensor posición recogida = ABIERTA · Z = sensor posición extendida = CERRADA · A y C = pulsadores · I = electroválvula abrir (hacia Y) · D = electroválvula cerrar (hacia Z) · V = led verde (abierta) · R = led rojo (cerrada)

Caja azul = estado actual · rombos = decisión de contador (CTR5→125, CTR6→150, CTR3→75; 1 pulsación de reloj = 1 tick; 5 s = 125 pulsaciones) · flecha discontinua = permanencia (mantiene la pulsación o el contador aún no llega a FIN)

ctr5 ctr5 ctr6 ctr3 CIERRE_INICIALD = 1 CERRADAR = 1 ESPERA_A_5SR = Z · CTR5 → 125 ABRIRI = 1 (abre → Y) ABIERTAV = 1 (abierta) ESPERA_C_5SV = Y · CTR5 → 125 CERRARD = 1 (cierra → Z) ESPERA_A_3Ssin salidas · CTR3 → 75 ESPERA_C_6SV = Y · CTR6 → 150 Z = 1 A = 1 A=0 · FIN_CTR5 Y = 1 C = 1 C=0 · FIN_CTR6 C = 1 C=0 · FIN_CTR5 Z = 1 A = 1 A=0 · FIN_CTR3 A=1 · espera  |  A=0 · ctr<125 C=1 · espera  |  C=0 · ctr<125 C=1 · espera  |  C=0 · ctr<150 A=1 · espera  |  A=0 · ctr<75
Estado y reloj
t = 0 · estado: CIERRE_INICIAL
CTR5: 0 / 125
1 tick = 1 pulsación de reloj · FIN al llegar al tope con el pulsador soltado
Entradas (A y C pulsadores · Y y Z sensores de posición)
Salidas (siguen el estado actual; las que van entre paréntesis en la guía siguen a Y/Z)
I · electroválvula abrir (→ Y) D · electroválvula cerrar (→ Z) V · led verde, abierta R · led rojo, cerrada
Registro de transiciones (pasa el ratón sobre una línea para resaltar la arista)

Bloques ASM (uno por estado; entre corchetes las salidas activas del estado; ninguna transición = permanecer en el estado):

# Estado (bloque ASM) Salidas Decisiones → siguiente estado
1 CIERRE_INICIAL D=1 Z=1 → CERRADA
2 CERRADA R=1 (=Z) A=1 → ESPERA_A_5S
3 ESPERA_A_5S (R=Z) A=1: espera; A=0: CTR5 cuenta; FIN_CTR5 → ABRIR
4 ABRIR I=1 Y=1 → ABIERTA; C=1 → ESPERA_C_6S
5 ESPERA_C_6S (V=Y) C=1: espera; C=0: CTR6 cuenta; FIN_CTR6 → CERRAR
6 ABIERTA V=1 (=Y) C=1 → ESPERA_C_5S
7 ESPERA_C_5S (V=Y) C=1: espera; C=0: CTR5 cuenta; FIN_CTR5 → CERRAR
8 CERRAR D=1 Z=1 → CERRADA; A=1 → ESPERA_A_3S
9 ESPERA_A_3S — A=1: espera; A=0: CTR3 cuenta; FIN_CTR3 → ABRIR

Grafo de transiciones (en el diagrama ASM cada fila es un bloque con su caja de estado, caja condicional de salidas y cajas de decisión):

stateDiagram-v2 [*] --> CIERRE_INICIAL CIERRE_INICIAL --> CERRADA : Z=1 CERRADA --> ESPERA_A_5S : A=1 ESPERA_A_5S --> ABRIR : A=0 y FIN_CTR5 (5 s) ABRIR --> ABIERTA : Y=1 ABRIR --> ESPERA_C_6S : C=1 ESPERA_C_6S --> CERRAR : C=0 y FIN_CTR6 (6 s) ABIERTA --> ESPERA_C_5S : C=1 ESPERA_C_5S --> CERRAR : C=0 y FIN_CTR5 (5 s) CERRAR --> CERRADA : Z=1 CERRAR --> ESPERA_A_3S : A=1 ESPERA_A_3S --> ABRIR : A=0 y FIN_CTR3 (3 s)

Claves del planteamiento (puntos del enunciado): - "5/6/3 segundos DESPUÉS DE SOLTAR": mientras el pulsador sigue a 1 el contador no cuenta (ramilla A=0 / C=0 antes de la decisión FIN). - "si alcanza alguna posición límite se detendrá": en ABRIR, Y=1 → ABIERTA (I deja de activarse); en CERRAR, Z=1 → CERRADA (D se apaga). - Al conectar: estado CIERRE_INICIAL con D=1 hasta Z (cerrar si no lo estaba; la figura fija la regla de oro: límite derecho = Z = todo extendido = CERRADA, porque la trampilla tapa el cuello de la tolva a la derecha del cilindro). - Los dos estados de 5 s son distintos bloques (origen C desde cerrada ≠ origen A desde cerrada en reposo) aunque compartan contador: hay que dibujar los 9 bloques. - Durante las esperas el cilindro está parado (ninguna salida I/D).

📚 Teoría: Tema 3, pág. 15–19 del PDF «Tema 3 SD-II_20200413.pdf» — diagramas ASM: estado, salidas, decisiones. 📚 Teoría: Tema 3, pág. 22 del PDF «Tema 3 SD-II_20200413.pdf» — diagrama de estados y ASM equivalentes.

c) Módulo VHDL respetando los nombres ASM (1,25 p)

En el VHDL las comparaciones de los límites y las consignas de los LEDs (R←Z, V←Y) siguen la figura del enunciado (Z = cerrada, Y = abierta): los nombres de estados, la estructura y los contadores son los del ASM, escritos con el pattern de clase de Tema 3 (págs. 30–32): un solo proceso con wait until clk='1', reset síncrono y las salidas dentro de cada rama. Analizado con GHDL 4.1.0 (--std=08 -fsynopsys) y verificado con un testbench que exploita la retícula determinista de la pre-escala (arranca en 0 con el reset y envuelve cada PRE+1 flancos) y comprueba, flanco a flanco y con asserts de exactitud: cierre inicial con D hasta Z; que con el pulsador mantenido el contador NO avanza (mantenido más allá de las 125/150/75 envolturas necesarias); que tras soltar, la salida se produce exactamente en la envoltura 125ª (5 s), 150ª (6 s) y 75ª (3 s) respectivamente; paradas en finales de carrera con el LED correcto (R solo en CERRADA, V solo en ABIERTA, y R=Z / V=Y durante las esperas); y reset a mitad de cuenta que limpia y rearma la retícula desde cero. Escala de simulación PRE=9: TEST PASSED (257.151 ns); segunda escala PRE=49: TEST PASSED (1.217.151 ns) — asserts calculados sobre las constantes, linealidad exacta. Extrapolado a escala real (PRE=999.999): las pausas son 125·10⁶, 150·10⁶ y 75·10⁶ flancos de 25 MHz = 5,000 / 6,000 / 3,000 s justos (más la latencia de 1 flanco de la rama de salidas). Scripts: control_trampilla.vhd y tb_control_trampilla.vhd en ~/.hermes/cache/scratch/vhdl-jun26/.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;      -- suma/comparaciones sobre vectores (estilo de clase)

entity Control_Trampilla is
    generic (
        G_PRE_MAX : integer := 999_999;  -- pre-escala MOD-1e6: 25 MHz -> tick cada 40 ms
        G_T5      : integer := 125;      -- MOD-125 de ticks = 5,000 s (CTR5)
        G_T6      : integer := 150;      -- MOD-150 de ticks = 6,000 s (CTR6)
        G_T3      : integer := 75        -- MOD-75  de ticks = 3,000 s (CTR3)
    );
    port (
        clk, reset : in  std_logic;      -- reloj de 25 MHz; reset sincrono (Tema 3 p.30)
        A, C, Y, Z : in  std_logic;      -- pulsadores y finales de carrera
        V, R, I, D : out std_logic       -- led verde / led rojo / cilindro abre / cilindro cierra
    );
end entity Control_Trampilla;

architecture ASM of Control_Trampilla is
    -- nombres de estado = nombres de los bloques del diagrama ASM
    type mis_estados is (CIERRE_INICIAL, CERRADA, ESPERA_A_5S, ABRIR,
                         ESPERA_C_6S, ABIERTA, ESPERA_C_5S, CERRAR, ESPERA_A_3S);
    signal estado : mis_estados;

    signal pre  : std_logic_vector(19 downto 0);  -- pre-escala MOD-1e6 compartida
    signal cnt5 : std_logic_vector(7 downto 0);   -- llega a 149: 8 bits (MOD-150 es el mayor)
    signal cnt6 : std_logic_vector(7 downto 0);
    signal cnt3 : std_logic_vector(6 downto 0);   -- llega a 74
begin
    process
        begin
            wait until clk = '1';
            if (reset = '1') then             -- reset sincrono: arranque = cierre inicial
                estado <= CIERRE_INICIAL;
                pre  <= (others => '0');
                cnt5 <= (others => '0');  cnt6 <= (others => '0');  cnt3 <= (others => '0');
                V <= '0'; R <= '0'; I <= '0'; D <= '0';
            else
                if pre = G_PRE_MAX then pre <= (others => '0');
                else                    pre <= pre + 1;   -- pre-escala siempre cuenta: tick cada 40 ms
                end if;
                case estado is
                    when CIERRE_INICIAL =>    -- al conectar, cerrar si no lo estaba
                        D <= '1'; V <= '0'; R <= '0'; I <= '0';
                        if Z = '1' then estado <= CERRADA; end if;

                    when CERRADA =>           -- posicion limite cerrada (Z extendida)
                        R <= '1'; V <= '0'; I <= '0'; D <= '0';
                        cnt5 <= (others => '0');
                        if A = '1' then estado <= ESPERA_A_5S; end if;

                    when ESPERA_A_5S =>       -- 5 s DESPUES DE SOLTAR A
                        R <= Z; V <= '0'; I <= '0'; D <= '0';
                        if A = '1' then
                            cnt5 <= (others => '0');   -- boton aun pulsado: no cuenta
                        elsif pre = G_PRE_MAX then
                            if cnt5 = G_T5 - 1 then
                                cnt5 <= (others => '0');   -- salida limpia
                                estado <= ABRIR;
                            else cnt5 <= cnt5 + 1; end if;
                        end if;

                    when ABRIR =>             -- moviendose a la izquierda (abrir)
                        I <= '1'; V <= '0'; R <= '0'; D <= '0';
                        cnt5 <= (others => '0'); cnt6 <= (others => '0');
                        if Y = '1' then estado <= ABIERTA;
                        elsif C = '1' then estado <= ESPERA_C_6S; end if;

                    when ESPERA_C_6S =>       -- 6 s DESPUES DE SOLTAR C (interrupcion de apertura)
                        V <= Y; R <= '0'; I <= '0'; D <= '0';
                        if C = '1' then
                            cnt6 <= (others => '0');
                        elsif pre = G_PRE_MAX then
                            if cnt6 = G_T6 - 1 then
                                cnt6 <= (others => '0');
                                estado <= CERRAR;
                            else cnt6 <= cnt6 + 1; end if;
                        end if;

                    when ABIERTA =>           -- posicion limite abierta (Y recogida)
                        V <= '1'; R <= '0'; I <= '0'; D <= '0';
                        cnt5 <= (others => '0');
                        if C = '1' then estado <= ESPERA_C_5S; end if;

                    when ESPERA_C_5S =>       -- 5 s DESPUES DE SOLTAR C (desde ABIERTA)
                        V <= Y; R <= '0'; I <= '0'; D <= '0';
                        if C = '1' then
                            cnt5 <= (others => '0');
                        elsif pre = G_PRE_MAX then
                            if cnt5 = G_T5 - 1 then
                                cnt5 <= (others => '0');
                                estado <= CERRAR;
                            else cnt5 <= cnt5 + 1; end if;
                        end if;

                    when CERRAR =>            -- moviendose a la derecha (cerrar)
                        D <= '1'; V <= '0'; R <= '0'; I <= '0';
                        cnt3 <= (others => '0');
                        if Z = '1' then estado <= CERRADA;
                        elsif A = '1' then estado <= ESPERA_A_3S; end if;

                    when ESPERA_A_3S =>       -- 3 s DESPUES DE SOLTAR A (interrupcion de cierre)
                        V <= '0'; R <= '0'; I <= '0'; D <= '0';
                        if A = '1' then
                            cnt3 <= (others => '0');
                        elsif pre = G_PRE_MAX then
                            if cnt3 = G_T3 - 1 then
                                cnt3 <= (others => '0');
                                estado <= ABRIR;
                            else cnt3 <= cnt3 + 1; end if;
                        end if;

                    when others => estado <= CIERRE_INICIAL;
                end case;
            end if;
        end process;
end architecture ASM;

Notas para el examen: la «habilitación» del contador es la propia rama del estado (el contador solo cuenta dentro de su estado de espera) y además la ramilla A = '0' / C = '0': con el botón pulsado la rama pone el contador a cero en cada flanco, que es la traducción directa de «empieza al SOLTAR». El contador se escribe en std_logic_vector con la suma y la comparación de estilo de clase (STD_LOGIC_UNSIGNED); el generic es solo para simular — en el examen se comparan las constantes reales 999_999, 124, 149 y 74. Los tres contadores comparten la pre-escala, que cuenta libre: la cuenta de cada pausa se mide en ticks desde la ramilla de soltado, y cada estado de espera limpia su contador mientras el botón sigue pulsado.

📚 Teoría: Tema 3, pág. 23–24 del PDF «Tema 3 SD-II_20200413.pdf» — diagrama ASM y módulo VHDL equivalente. 📚 Teoría: Tema 3, pág. 30–32 del PDF «Tema 3 SD-II_20200413.pdf» — traducción de ASM a VHDL (antirrebote). 📚 Teoría: Tema 2, pág. 14–16 del PDF «Tema 2 SD-II_20200317.pdf» — biestables en VHDL: memoria implícita. 📚 Teoría: Tema 2, pág. 56 del PDF «Tema 2 SD-II_20200317.pdf» — contador síncrono de 4 bits en VHDL.

Errores típicos — P2

Esquema-resumen de la metodología

  1. Leer la figura antes que nada y fijar la semántica física — la geometría manda: con el vástago entrando en el cuello de la tolva a la derecha, Z (todo extendido) = CERRADA e Y (todo recogido) = ABIERTA; I abre y D cierran sin permutarse (solo se intercambian los finales de carrera) y V/R son los LEDs de abierta/cerrada.
  2. Enumerar entradas y salidas de la unidad de control — entradas A, C (pulsadores) e Y, Z (finales de carrera); salidas I, D (cilindro) y V, R (LEDs); se anotan las garantías del enunciado (A y C nunca a la vez, Y y Z nunca simultáneos), que luego simplifican las decisiones.
  3. Traducir los segundos a pulsos de reloj con pre-escala — T = 40 ns; 5/6/3 s son 125/150/75 millones de pulsos; se descompone 10⁶ × (125/150/75): pre-escala MOD-10⁶ compartida (25 MHz → 25 Hz, tick de 40 ms) más contadores MOD-125/150/75 sobre el tick.
  4. Diseñar la ASM con un bloque por estado y nombres propios — caja de estado con sus salidas activas, decisiones encadenadas y permanencia cuando no cabe transición; aquí salen 9 estados, incluidos los dos bloques de 5 s, distintos aunque compartan contador.
  5. Volcar en el grafo las trampas del enunciado — el contador se habilita solo al SOLTAR el pulsador (ramilla A=0/C=0 antes de la decisión FIN); alcanzar el límite detiene el motor (Y=1→ABIERTA, Z=1→CERRADA); al conectar hay CIERRE_INICIAL con D hasta Z; los LEDs solo indican posición límite.
  6. Escribir el VHDL 1:1 con los nombres de la ASM — type mis_estados con los nombres de los bloques; un solo proceso con wait until clk='1' más if reset='1' (síncrono: deja CIERRE_INICIAL, cuentas a cero y salidas en reposo); pre-escala que cuenta siempre, contadores en std_logic_vector con la suma de STD_LOGIC_UNSIGNED, y las salidas escritas dentro de cada rama del case (when others => incluido).
  7. Verificar la cuenta FIN de cada contador — MOD-N sobre el tick: N × 40 ms debe dar exactamente 5,000/6,000/3,000 s (y 5 s = 125 000 000 pulsos de 25 MHz, no 5 × 25 000).
  8. Simular la secuencia completa con testbench — cierre inicial, esperas de 5/6/3 s tras soltar el pulsador, paradas en finales de carrera y LEDs correctos: cada situación del enunciado debe verse reflejada en la simulación.

Idea transversal: la semántica la fija la geometría de la figura y ningún tiempo del enunciado se cuenta a ojo: todo se traduce a pulsos con pre-escala + contador; y ASM y VHDL son el mismo diseño dicho dos veces, con los mismos nombres bloque a bloque.


Problema 3 — Microcontrolador PicoBlaze (3 puntos)

Enunciado íntegro del Problema 3 (PicoBlaze), con la tabla de instrucciones que hay que usar en el examen.
Enunciado íntegro del Problema 3 (PicoBlaze), con la tabla de instrucciones que hay que usar en el examen.

Planteamiento. Un PicoBlaze (núcleo KCPSM) lee 4 puertos de entrada (14, 16, 29, 30) y los guarda en su RAM scratchpad en la posición cuyo número es el mismo del puerto (H'0E', H'10', H'1D', H'1E'; lectura literal de «guardará estos valores en las mismas posiciones de la RAM»). La RAM se declara suficiente hasta H'1E'. Realiza tres operaciones con los datos recuperados, sacando resultados por los puertos de salida 127, 220 y 223. El programa es un bucle infinito a)→d); una interrupción (vector en la última posición de la ROM, 3FFH: JUMP ISR; el hardware ya apila el PC, preserva Z/C, enmascara y fuerza el fetch del vector) borra las 3 salidas y toda la RAM declarada (H'00'–H'1E') y reinicia el programa. La ROM de programa es EXTERNA al módulo KCPSM y debe aparecer en el diagrama.

Decisiones de diseño del planteamiento. La posición RAM de cada dato es el mismo número del puerto (lectura literal de «las mismas posiciones de la RAM»; EQU simbólicos H"0E"/H"10"/H"1D"/H"1E"), y la RAM se declara suficiente hasta H'1E'. En el vector de interrupción (3FFH) basta JUMP ISR: el hardware ya hace él solo el CALL. La ISR borra las 3 salidas y toda la RAM declarada, H'00'–H'1E' (limpiar solo las 4 posiciones usadas es interpretación con riesgo de perder puntos), no lleva EINT dentro y termina con JUMP INICIO («volverá a empezar desde el principio»). El desarrollo y la justificación de cada decisión, en el apartado b).

Nombres simbólicos (EQU) usados: puertos y direcciones RAM.

P_IN14   EQU H"0E"   ; puerto entrada 14 (decimal)
P_IN16   EQU H"10"   ; puerto entrada 16
P_IN29   EQU H"1D"   ; puerto entrada 29
P_IN30   EQU H"1E"   ; puerto entrada 30
P_OUT127 EQU H"7F"   ; puerto salida 127
P_OUT220 EQU H"DC"   ; puerto salida 220
P_OUT223 EQU H"DF"   ; puerto salida 223
R14      EQU H"0E"   ; RAM scratchpad: la direccion = nº del puerto (14 = H'0E')
R16      EQU H"10"   ; dato del puerto 16 -> H'10'
R29      EQU H"1D"   ; dato del puerto 29 -> H'1D'
R30      EQU H"1E"   ; dato del puerto 30 -> H'1E'

a) Diagrama lógico detallado incluyendo la memoria de programa (1 p)

clk (reloj FPGA) reset (sincronizado) dispositivo que genera interrupcion (int) pulso de al menos 2 clk KCPSM (firmcore PicoBlaze) embebido dentro de la FPGA registros s0–sF + ALU program counter de 9 bits pila de hardware (3 niveles) control: genera port_id y strobes RAM scratchpad fuera del nucleo (FETCH/STORE, no se dibuja) ROM de programa 1024 × 18 block RAM de la FPGA (NO dentro del nucleo) 000H–3FEH: instrucciones 3FFH: JUMP ISR ← vector de interrupcion Al activarse int el hardware apila PC, preserva Z/C, enmascara y fetchea 3FFH (hace el CALL el solo) clk reset int dir (9:0) instr (18) Lógica de E/S en la FPGA (fuera del núcleo) los puertos se eligen comparando port_id y strobes Entrada 14 (8 b) Entrada 16 (8 b) Entrada 29 (8 b) Entrada 30 (8 b) = H"0E" = H"10" = H"1D" = H"1E" MUX 4:1 = H"7F" (P127) = H"DC" (P220) = H"DF" (P223) AND AND AND Latch 8 b dato+5 ó 1 Latch 8 b suma (ó 0) Latch 8 b H"FF" ó +10 port_id+rd input_port(7:0) output_port(7:0) wr dir(9:0)=program_port_addr · instr(18)=program_port_instruction · rojo discontinuo = port_id y strobes · negro = datos Los puertos no usan bus de direcciones externo: port_id acompaña a read_strobe/write_strobe (KCPSM3 añade output_port_strobe).

Figura: diagrama lógico del PicoBlaze con su memoria de programa y la lógica de puertos (apartado a).

Dibujar y conectar (descripción textual de lo que debe aparecer):

  1. Bloque KCPSM (firmcore PicoBlaze, embebido en la FPGA) con sus puertos: clk, reset, interrupt_port (entrada int), input_port(7:0), output_port(7:0), program_port_addr(9:0), program_port_instruction(17:0), strobes read_strobe / write_strobe (en KCPSM3 también output_port_strobe(7:0)), y las líneas internas de port_id (8 bits).
  2. Memoria de programa: ROM 1024 × 18 (block/distributed RAM) — NO está dentro del núcleo: direcciones 000H–3FEH = instrucciones ensambladoras; dirección 3FFH = JUMP ISR (vector de interrupción: al producirla, el hardware apila el PC, preserva Z/C, enmascara y fuerza el fetch de esa dirección por sí solo). program_port_addr sale del núcleo a la ROM; program_port_instruction vuelve a él. Dibujarla SIEMPRE (vale 1 punto).
  3. Decodificación de puertos (lógica FPGA fuera del núcleo): - Lectura: comparadores de port_id con H"0E", H"10", H"1D", H"1E" que seleccionan (multiplexor) qué dispositivo de entrada conduce input_port, junto con read_strobe. - Escritura: comparadores con H"7F", H"DC", H"DF" que, AND con write_strobe, habilitan el registro/latch de salida de cada puerto desde output_port.
  4. Dispositivos externos: 4 entradas (sensores/interruptores a 8 bits) a las entradas del multiplexor; 3 registros de salida de 8 bits hacia sus periféricos; la línea int (pulso ≥ 2 clk) al interrupt_port.
  5. Reloj y reset conectados. Ningún bus de datos externo con direcciones: los "bus de E/S" del PicoBlaze son el input_port/output_port de 8 bits + port_id.

📚 Teoría: Tema 4, pág. 11–12 del PDF «Tema 4 SD-II_20220512.pdf» — arquitectura PicoBlaze: bloques y pila. 📚 Teoría: Tema 4, pág. 31–34 del PDF «Tema 4 SD-II_20220512.pdf» — puertos: PORT_ID, strobes y conexión. 📚 Teoría: Tema 4, pág. 45 y 49 del PDF «Tema 4 SD-II_20220512.pdf» — ROM de programa externa: bloque RAM 1Kx18. 📚 Teoría: Tema 1, pág. 12–13 del PDF «Tema 1 SD-II_20200206.pdf» — multiplexores: selectores de datos.

b) Programa ensamblador comentado (2 p)

Problema 3 · Emulador PicoBlaze interactivo

El programa lee los puertos 14, 16, 29, 30 y los guarda en la RAM scratchpad en la posición de número igual al del puerto (H'0E', H'10', H'1D', H'1E'); saca resultados por los puertos 127, 220 y 223 en bucle a)→b)→c)→d)→a). La interrupción (vector en 3FFH: JUMP ISR; el hardware ya apila el PC, preserva Z/C, enmascara y fuerza el fetch del vector) borra las 3 salidas y toda la RAM declarada (H'00'–H'1E') y reinicia en INICIO (que re-arma con EINT).

Doctrina de flags (igual que el emulador de referencia): tras ADD, CY=1 si hay carry-out; tras SUB/COMP, CY=1 si hay préstamo; ADD/SUB usan la CY entrante solo en sus formas ADDC/SUBC. El COMP s7,H"01" previo solo normaliza Z; el resultado del programa no depende de la CY que deja. Nunca RETI tras la ISR: queda enmascarada hasta EINT.

Entradas en decimal (0–255); se leen en el siguiente IN.

El enunciado exige el programa «debidamente comentado»: cada región lleva un encabezado en comentario que explica su qué y su porqué, más alguna línea suelta solo donde merezca la pena (valores mágicos como H"1E" o H"32", y la aritmética con carry). Un comentario en cada línea no es legible y no puntúa más. Directrices: ORG para la posición de la ROM; el vector de interrupción en la última posición (3FFH). La nomenclatura sigue la tabla impresa del examen: IN/OUT (no INPUT/OUTPUT), formas constantes sin paréntesis (IN s0,H"0E", STORE s0,R14) y paréntesis solo en la forma indirecta (STORE s0,(s1)).

;==================== vector de interrupcion =====================
; La ROM de programa acaba siempre en su ultima posicion (3FFH). Al producirse
; la interrupcion el HARDWARE hace el CALL al vector el solo: apila el PC,
; preserva Z/C y enmascara las interrupciones. Aqui solo hace falta el salto:
; JUMP ISR es lo que "aprovecha" el mecanismo de interrupcion del PicoBlaze.
        ORG H"3FF"
        JUMP ISR

;==================== programa principal (cabecera INICIO) ========
; Bucle infinito a) -> b) -> c) -> d) -> a) ... Cada vuelta pasa por INICIO,
; que prepara s7 = 0 (el registro "cero" con el que luego se borran las
; salidas) y re-arma la interrupcion con EINT: tras ser atendida queda
; enmascarada, y la tabla impresa no tiene DINT.
        ORG H"000"
INICIO: LOAD s7, H"00"        ; s7 = 0 durante toda la ejecucion
        COMP s7, H"01"        ; defensivo: deja CY=0 (ver la nota de SUMA5)
        EINT
; ---- a) leer los 4 puertos y guardarlos en la RAM scratchpad ----
; El enunciado dice literalmente que "guardara estos valores en las mismas
; posiciones de la RAM": la posicion de cada dato es el MISMO numero del puerto
; (puerto 14 -> H'0E', 16 -> H'10', 29 -> H'1D', 30 -> H'1E'), y asi queda
; reutilizable en los apartados b), c) y d).
        IN s0, P_IN14
        STORE s0, R14
        IN s1, P_IN16
        STORE s1, R16
        IN s2, P_IN29
        STORE s2, R29
        IN s3, P_IN30
        STORE s3, R30
; ---- b) puerto 14: si vale 30 o 40, sumar 5 y sacarlo por 127 ----
; Se compara el dato guardado en a) con los dos unicos valores que admite el
; enunciado: H"1E" = 30 y H"28" = 40 (decimales). Si coincide, se suma 5; si
; no, por el puerto de salida 127 (H"7F") debe salir un 1.
        FETCH s4, R14
        COMP s4, H"1E"        ; ¿vale 30 decimal?
        JUMP Z, SUMA5         ;   si -> sumar 5
        COMP s4, H"28"        ; ¿vale 40 decimal?
        JUMP Z, SUMA5         ;   si -> sumar 5
        LOAD s4, H"01"        ; no es 30 ni 40: preparo el valor 1
        OUT s4, P_OUT127
        JUMP PASO_C
SUMA5:  COMP s7, H"01"        ; redundante con esta tabla porque ADD no usa la
                              ; CY de entrada; se deja por seguridad
        ADD s4, H"05"         ; sumo 5 al dato del puerto 14
        OUT s4, P_OUT127
; ---- c) sumar RAM(puerto 16) + RAM(puerto 29) -> puerto 220 ----
; Suma de dos registros: el resultado de 8 bits queda en s5 y, si la suma real
; pasa de 255, el acarreo sale por CY. Con acarreo hay que restar 50 (H"32")
; al resultado; sin acarreo la salida 220 (H"DC") se pone a 0.
PASO_C: COMP s7, H"01"
        FETCH s5, R16
        FETCH s6, R29
        ADD s5, s6            ; ADD ignora la CY entrante y produce CY=1 si la
                              ; suma se pasa de 255 (acarreo hacia fuera)
        JUMP NC, CERO_220     ; CY=0: no hubo acarreo, la suma cupo en 8 bits
        SUB s5, H"32"         ; acarreo: p.ej. 150+120=270 deja s5=0EH (que es
                              ; 270-256) y CY=1. SUB resta sin mirar esa CY:
                              ; 0EH-32H = -36 = DCH en 8 bits (el prestamo
                              ; devuelve los 256 del carry), o sea (270-50)
                              ; mod 256 = 220. Por eso el byte es exacto
        OUT s5, P_OUT220
        JUMP PASO_D
CERO_220:                     ; rama sin acarreo
        OUT s7, P_OUT220      ; saca el registro "cero"
; ---- d) puerto 30: MSB=1 -> todo unos en 223; MSB=0 -> +10 ----
; Se prueba el bit 7 con la mascara H"80": TEST deja Z=1 cuando el bit probado
; es 0 (al reves de lo que parece). Con MSB=1 el puerto 223 (H"DF") se pone a
; H"FF", todas sus lineas a 1; con MSB=0 se suma 10.
PASO_D: FETCH s4, R30
        TEST s4, H"80"        ; solo afecta a Z: Z=1 si el bit 7 era 0
        JUMP Z, MAS10
        LOAD s4, H"FF"        ; MSB=1: pongo a uno TODAS las salidas del puerto
        OUT s4, P_OUT223
        JUMP INICIO
MAS10:  COMP s7, H"01"
        ADD s4, H"0A"         ; sumo 10 (H"0A") al valor del puerto 30
        OUT s4, P_OUT223
        JUMP INICIO           ; cierre del bucle infinito (a -> d -> a ...)
;==================== rutina de interrupcion (ISR) ================
; El hardware entra aqui al atender la interrupcion (ya paso por el vector). El
; enunciado exige borrar las 3 salidas y TODA la RAM: la RAM DECLARADA llega
; hasta H'1E' (la mayor direccion usada, la del puerto 30; el nucleo KCPSM6
; trae mas posiciones de serie) -> "toda la RAM" = la RAM declarada,
; H'00'-H'1E'. La RAM no se recorre con constantes -> registro indice s1 +
; forma indirecta STORE s0,(s1).
; Destruir el s1 del programa principal es inocuo: tras la ISR hay reinicio.
ISR:    LOAD s0, H"00"        ; s0 = 0, valor de borrado (salidas y RAM)
        OUT s0, P_OUT127
        OUT s0, P_OUT220
        OUT s0, P_OUT223
        LOAD s1, H"00"        ; indice de recorrido de la RAM
LIMPIA: STORE s0, (s1)        ; borro la posicion RAM apuntada por s1 (indirecto)
        ADD s1, H"01"         ; siguiente posicion
        COMP s1, H"1F"        ; tope H"1F" = 31: se limpian H'00'-H'1E' (la RAM
                              ; declarada); COMP deja CY=0 solo cuando s1 >= H'1F'
        JUMP NC, INICIO       ; RAM entera limpia -> reinicio ("volvera al principio")
        JUMP LIMPIA           ; mientras s1 < H'1F', sigo borrando

Nota sobre el final de la ISR (JUMP INICIO, explicar en el examen): lo canónico sería cerrar la ISR con RETI, pero RETI reanuda el programa principal a mitad del bucle (en el punto interrumpido) y el enunciado obliga a volver desde el principio: se acaba con JUMP INICIO. La entrada que el hardware apiló al producirse la interrupción (el retorno de su CALL implícito al vector 3FFH) queda sin desapilar, pero es inocua: la pila hardware del PicoBlaze es circular de 3 niveles y el programa nunca usa RETURN. El re-arme de interrupciones lo hace el EINT de INICIO en cada vuelta del bucle: tras ser atendida, la interrupción queda enmascarada (solo EINT/RETI la re-habilitan) y dentro de la ISR está prohibido poner EINT —el re-arme pertenece a INICIO—. Sin ese EINT en INICIO el sistema solo podría interrumpirse una vez. (La tabla impresa no tiene DINT: solo EINT/RETI.)

Ejemplo comprobado a mano (entradas: P14=40, P16=150, P29=120, P30=200): - a) RAM: [0E]=28H, [10]=96H, [1D]=78H, [1E]=C8H (cada dato, en la dirección de número igual al de su puerto). - b) 40 = H'28' → SUMA5: 40+5 = 45 → puerto 127 = 45 (2DH). - c) 150+120 = 270 = 1_0E(8)… en 8 bits: ADD deja s5=0EH y produce CY=1 (la CY solo flaggea el acarreo; SUB no la usa). 0EH − 32H = −36 = DCH (220, módulo 256; el préstamo es normal en 8 bits: 270 − 50 = 220) → puerto 220 = 220. - d) 200 = C8H, bit 7 = 1 → puerto 223 = FFH (255). - Sin acarreo (P16=100, P29=120 → 220 < 256): puerto 220 = 0. - Interrupción a mitad de iteración → tras la ISR: puertos 127/220/223 = 0, toda la RAM declarada (H'00'–H'1E') a 0, y el programa reinicia en INICIO con EINT re-armado (comprobado con un emulador KCPSM).

📚 Teoría: Tema 4, pág. 27–30 del PDF «Tema 4 SD-II_20220512.pdf» — flags ZERO/CARRY: TEST, COMP, JUMP, CALL. 📚 Teoría: Tema 4, pág. 40–42 del PDF «Tema 4 SD-II_20220512.pdf» — scratchpad RAM: STORE/FETCH e indirecto. 📚 Teoría: Tema 4, pág. 37–39 del PDF «Tema 4 SD-II_20220512.pdf» — interrupciones: EINT, vector, ISR.

Errores típicos — P3

Esquema-resumen de la metodología

  1. Asignar EQU a puertos y direcciones RAM antes de programar — puertos decimales a hex (14→H"0E" … 30→H"1E"; 127→H"7F"); el enunciado fija que la dirección RAM de cada dato es el mismo número de su puerto, y la mayor de esas direcciones (H'1E') declara la RAM suficiente.
  2. Dibujar el diagrama con la ROM de programa fuera del núcleo — ROM 1024×18 con el vector en la última posición 3FFH (JUMP ISR); decodificación de puertos fuera del núcleo: comparadores de port_id con read_strobe y MUX para las lecturas; comparadores + AND con write_strobe + latches de 8 bits para las escrituras; int (pulso ≥ 2 clk), clk y reset.
  3. Escribir el programa por regiones con encabezado comentado — vector, cabecera INICIO, apartados a)-d) e ISR: cada encabezado explica qué y porqué, y se comentan aparte solo los valores mágicos y la aritmética con carry (un comentario por línea no es legible ni puntúa más).
  4. Montar el bucle infinito a)→d) — IN de los 4 puertos + STORE en su dirección RAM, operaciones condicionales de b)-d) encadenadas con JUMP entre apartados, y JUMP INICIO al final de d) que cierra a)→d)→a).
  5. Justificar el flag de cada decisión — COMP deja Z=1 en la coincidencia y CY marca el acarreo hacia fuera; en la tabla impresa ADD/SUB no leen la CY de entrada (solo la producen); TEST con H"80" deja Z=1 si el bit probado es 0, al revés de lo que parece: el JUMP se elige con ese criterio.
  6. Aprovechar lo que el hardware de interrupción ya hace solo — apila el PC, salva Z/C y enmascara, así que en el vector basta JUMP ISR; la ISR borra las 3 salidas y TODA la RAM declarada (bucle indirecto con registro índice hasta H'1E') y termina con JUMP INICIO porque el enunciado exige reiniciar; EINT solo se re-arma en INICIO, nunca dentro de la ISR.
  7. Ejecutar el programa completo y comprobar cada rama — un ejemplo a mano con datos concretos por ambos lados de cada condición (con y sin acarreo, MSB=0 y MSB=1), más un emulador KCPSM con asserts de cada salida y de la ISR (3 puertos y RAM H'00'–H'1E' a 0, reinicio con EINT re-armado).

Idea transversal: ceñirse siempre a la tabla de instrucciones impresa del examen (IN/OUT, STORE kk directo sin paréntesis, TEST con Z invertido) y no reimplementar por software lo que el hardware ya hace él solo: el CALL al vector, la pila y el enmascaramiento.

Guía de estudio generada a partir de la guía del profesor. Las cifras y códigos están verificados (GHDL / emulador KCPSM6 / barridos de direcciones). Revisa el baremo de cada problema antes del examen.