Guía de resolución — Examen de Sistemas Digitales II, Julio 2025 (18-07-2025)

Guía modelo para preparar la convocatoria de nov-dic 2026. El examen tiene 3 problemas: máquina expendedora ASM + VHDL (4 p), PicoBlaze para el mismo problema (2,5 p) y mapa de memoria (3,5 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 — Máquina expendedora "ponchis": ASM + VHDL (4 puntos)

Enunciado íntegro del Problema 1 (máquina expendedora «ponchis»). El problema no lleva ninguna figura: toda la información está en el texto y en las dos tablas Señal/Salida.
Enunciado íntegro del Problema 1 (máquina expendedora «ponchis»). El problema no lleva ninguna figura: toda la información está en el texto y en las dos tablas Señal/Salida.

Planteamiento. Es una máquina de estados con un contador binario de importe acumulado (máximo posible 5+5 = 10 → bastan 4 bits, rango 0–15): cada ficha insertada suma 1, 2 o 5. En cuanto el acumulado alcanza o supera 6 se entrega el producto un solo ciclo, el contador pasa a contener el exceso (importe − 6) y unos estados de devolución lo descomponen golosamente en fichas de 5, 2 y 1, emitiendo un pulso de un ciclo por ficha devuelta, hasta volver a ESPERA. Así se cumplen a la vez: un solo producto, cambio exacto, salidas de un ciclo y máquina lista de nuevo.

Datos que fija el enunciado y decisiones de diseño. Fija el enunciado: el precio del producto (6 ponchis), las fichas admitidas (1, 2 y 5 ponchis, activas a nivel alto, solo puede insertarse una ficha a la vez y entre fichas la señal del lector vuelve a cero), las salidas ENTREGAR, D1, D2 y D5 —todas deben activarse durante un solo ciclo de reloj, y si hay que devolver más de una ficha se hacen seguidas una de otra—, y el comportamiento a)-e): acepta fichas, devuelve el cambio si se excede, entrega al alcanzar o superar el precio, solo entrega un producto y queda preparada de nuevo. Baremo: a) diagrama ASM: 2,5 p · b) módulo VHDL: 1,5 p. Decisiones de diseño (no las fija el enunciado): representar el importe acumulado con un contador binario en lugar de codificarlo en los estados; los nombres de los 7 estados (ESPERA, COMPRUEBA, ENTREGA, CALCAMBIO, DEVUELVE_5, DEVUELVE_2, DEVUELVE_1); la descomposición golosa del cambio en fichas de 5, 2 y 1; y el reset opcional del VHDL (el ASM no lo pide).

Datos y rango del cambio

Salida Acción (1 solo ciclo de reloj)
ENTREGAR entrega el producto (precio 6)
D5 / D2 / D1 devuelve una ficha de 5 / 2 / 1 ponchis

Entradas: F1, F2, F5 activas a nivel alto, una ficha a la vez.

El importe solo puede crecer mientras esté por debajo de 6 (máx 5) y la ficha que lo alcanza vale como mucho 5 → importe máximo 10 → exceso máximo 4. El desglose goloso del cambio es:

Exceso (importe−6) Devoluciones (un pulso cada una)
0 ninguna
1 D1
2 D2
3 D2 y luego D1
4 D2 y luego D2

Comentario de nivel: con precio 6 y fichas 1/2/5 el estado DEVUELVE_5 nunca llega a dispararse (cambio ≤ 4), pero el diseño lo incluye porque la salida D5 existe y el diagrama queda correcto para cualquier precio/fichas — así se pide en clase.

a) Diagrama ASM — 7 estados (2,5 p)

Problema 1 · Máquina expendedora «ponchis» — ASM de 7 estados con contador de importe

F1, F2, F5 = fichas de 1, 2 y 5 ponchis (nivel alto, una ficha a la vez; el lector vuelve a cero entre fichas) · IMPORTE = contador binario del importe acumulado (4 bits: máximo 5+5=10, rango 0–15) · precio 6 · salidas ENTREGAR, D5, D2, D1 activas exactamente 1 ciclo de reloj cada una

Caja azul = estado actual · las sumas van en las ramillas de ESPERA (sin estados SUMA aparte) · COMPRUEBA comparte la decisión IMPORTE≥6 · ENTREGA y DEVUELVE_x duran 1 solo ciclo (transición sin condición) y vuelven a CALCAMBIO, que desglosa el exceso golosamente (5/2/1) hasta IMPORTE=0 → ESPERA · pasa el ratón sobre el registro para resaltar la arista

ESPERAsin salidas COMPRUEBA¿alcanzado el precio? ENTREGAENTREGAR = 1 CALCAMBIOdesglose goloso 5/2/1 DEVUELVE_5D5 = 1 (1 ciclo) DEVUELVE_2D2 = 1 (1 ciclo) DEVUELVE_1D1 = 1 (1 ciclo) inicio F1=1 · +1 F2=1 · +2 F5=1 · +5 IMPORTE<6 IMPORTE≥6 1 clk · ENTREGAR=1 IMPORTE ← IMPORTE−6 IMPORTE≥5 D5=1 · −5 IMPORTE≥2 D2=1 · −2 IMPORTE≥1 D1=1 · −1 IMPORTE=0 · cambio dado nada (F1=F2=F5=0) · permanece
Estado y reloj (cada Paso = 1 ciclo de reloj)
t = 0 · estado: ESPERA · IMPORTE = 0
contador de 4 bits (0–15) · marca naranja = precio 6 · las restas lo dejan a 0 sin reset
ENTREGAR ×0 · D5 ×0 · D2 ×0 · D1 ×0
Lector de fichas (F1/F2/F5 = una ficha a la vez; se consume al aceptar la máquina)
cola de fichas: (vacía)
Salidas (cada una dura exactamente 1 ciclo: estados de transición sin condición)
ENTREGAR · producto (precio 6) D5 · ficha de 5 D2 · ficha de 2 D1 · ficha de 1
Registro de transiciones (ciclo a ciclo: condición, salidas del ciclo e importe antes→después)

Bloques ASM (uno por estado; entre corchetes las salidas activas del estado; "ninguna transición" = permanecer en el estado; las acciones ← son cargas del contador IMPORTE, registradas al flanco):

# Estado (bloque ASM) Salida Decisiones → siguiente estado (acción)
1 ESPERA — F1=1 → COMPRUEBA (IMPORTE←IMPORTE+1); F2=1 → COMPRUEBA (+2); F5=1 → COMPRUEBA (+5); nada → ESPERA
2 COMPRUEBA — IMPORTE≥6 → ENTREGA; IMPORTE<6 → ESPERA
3 ENTREGA ENTREGAR sin decisión (1 ciclo): IMPORTE←IMPORTE−6 → CALCAMBIO
4 CALCAMBIO — IMPORTE≥5 → DEVUELVE_5; ≥2 → DEVUELVE_2; ≥1 → DEVUELVE_1; =0 → ESPERA
5 DEVUELVE_5 D5 sin decisión (1 ciclo): IMPORTE←IMPORTE−5 → CALCAMBIO
6 DEVUELVE_2 D2 sin decisión (1 ciclo): IMPORTE←IMPORTE−2 → CALCAMBIO
7 DEVUELVE_1 D1 sin decisión (1 ciclo): IMPORTE←IMPORTE−1 → CALCAMBIO
stateDiagram-v2 [*] --> ESPERA ESPERA --> COMPRUEBA : F1=1 (IMPORTE+1) ESPERA --> COMPRUEBA : F2=1 (IMPORTE+2) ESPERA --> COMPRUEBA : F5=1 (IMPORTE+5) COMPRUEBA --> ENTREGA : IMPORTE>=6 COMPRUEBA --> ESPERA : IMPORTE<6 ENTREGA --> CALCAMBIO : 1 clk (ENTREGAR=1, IMPORTE-6) CALCAMBIO --> DEVUELVE_5 : IMPORTE>=5 CALCAMBIO --> DEVUELVE_2 : IMPORTE>=2 CALCAMBIO --> DEVUELVE_1 : IMPORTE>=1 CALCAMBIO --> ESPERA : IMPORTE=0 DEVUELVE_5 --> CALCAMBIO : 1 clk (D5=1, IMPORTE-5) DEVUELVE_2 --> CALCAMBIO : 1 clk (D2=1, IMPORTE-2) DEVUELVE_1 --> CALCAMBIO : 1 clk (D1=1, IMPORTE-1)

Claves del planteamiento (puntos del enunciado): - Las acciones de suma van en las ramillas de decisión de ESPERA (caja de acción sobre la rama SÍ); no hacen falta estados SUMA1/SUMA2/SUMA5 aparte. - La decisión IMPORTE≥6 se comparte para todos los caminos → estado COMPRUEBA. - Cada estado de salida (ENTREGA, DEVUELVE_x) dura exactamente 1 ciclo porque su transición de salida no tiene condición: así cada salida pulsa un solo reloj. - El cambio se emite de una en una ficha (D2 dos veces para el exceso 4), seguidas una de otra, separadas solo por el estado de decisión CALCAMBIO. - Tras el último pulso, CALCAMBIO ve IMPORTE=0 y vuelve a ESPERA: la máquina queda preparada sola (apartado e). - IMPORTE nunca necesita reset explícito en funcionamiento normal: las restas lo dejan a 0. (En VHDL el reset síncrono es obligatorio en la traducción Tema 3, ver código.)

Ejemplo de recorrido (5+5 = 10, cambio 4): ESPERA →(F5) COMPRUEBA[5] →ESPERA →(F5) COMPRUEBA[10] →ENTREGA(ENTREGAR=1, IMPORTE←4) →CALCAMBIO →DEVUELVE_2(D2, 2) →CALCAMBIO →DEVUELVE_2(D2, 0) →CALCAMBIO →ESPERA.

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

b) Módulo VHDL del ASM (1,5 p)

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;    -- aritmética de vectores, como en los apuntes

entity Expendedora is
    port (
        clk      : in  std_logic;                      -- reloj del sistema
        reset    : in  std_logic;                      -- puesta a cero (nivel alto)
        F1, F2, F5 : in  std_logic;                    -- fichas de 1, 2 y 5 (nivel alto)
        ENTREGAR : out std_logic;                      -- entrega el producto
        D5, D2, D1 : out std_logic                     -- devuelven una ficha de 5, 2 y 1
    );
end entity Expendedora;

architecture ASM of Expendedora is
    -- nombres de estado = nombres de los bloques del diagrama ASM
    type mis_estados is (ESPERA, COMPRUEBA, ENTREGA, CALCAMBIO,
                         DEVUELVE_5, DEVUELVE_2, DEVUELVE_1);
    signal estado : mis_estados;

    -- contador de importe acumulado: max 5+5 = 10 -> vector de 4 bits (0..15)
    signal importe : std_logic_vector(3 downto 0);
begin
    ------- proceso secuencial UNICO = ASM completo -------
    process
    begin
        wait until clk = '1';
        if reset = '1' then
            estado <= ESPERA;    importe <= "0000";
            ENTREGAR <= '0';  D5 <= '0';  D2 <= '0';  D1 <= '0';
        else
            case estado is
                when ESPERA =>                        -- esperando una ficha
                    ENTREGAR <= '0';  D5 <= '0';  D2 <= '0';  D1 <= '0';
                    if F1 = '1' then
                        importe <= importe + 1;   estado <= COMPRUEBA;
                    elsif F2 = '1' then
                        importe <= importe + 2;   estado <= COMPRUEBA;
                    elsif F5 = '1' then
                        importe <= importe + 5;   estado <= COMPRUEBA;
                    end if;
                when COMPRUEBA =>                     -- ¿alcanzado o superado el precio?
                    ENTREGAR <= '0';  D5 <= '0';  D2 <= '0';  D1 <= '0';
                    if importe >= 6 then  estado <= ENTREGA;
                    else                  estado <= ESPERA;
                    end if;
                when ENTREGA =>                       -- un ciclo: ENTREGAR a 1
                    ENTREGAR <= '1';  D5 <= '0';  D2 <= '0';  D1 <= '0';
                    importe <= importe - 6;           -- importe pasa a ser el exceso
                    estado <= CALCAMBIO;
                when CALCAMBIO =>                     -- descomposicion golosa del exceso
                    ENTREGAR <= '0';  D5 <= '0';  D2 <= '0';  D1 <= '0';
                    if importe >= 5 then     estado <= DEVUELVE_5;
                    elsif importe >= 2 then  estado <= DEVUELVE_2;
                    elsif importe >= 1 then  estado <= DEVUELVE_1;
                    else                     estado <= ESPERA;  -- cambio dado
                    end if;
                when DEVUELVE_5 =>                    -- un ciclo: D5 a 1
                    ENTREGAR <= '0';  D5 <= '1';  D2 <= '0';  D1 <= '0';
                    importe <= importe - 5;
                    estado <= CALCAMBIO;
                when DEVUELVE_2 =>                    -- un ciclo: D2 a 1
                    ENTREGAR <= '0';  D5 <= '0';  D2 <= '1';  D1 <= '0';
                    importe <= importe - 2;
                    estado <= CALCAMBIO;
                when DEVUELVE_1 =>                    -- un ciclo: D1 a 1
                    ENTREGAR <= '0';  D5 <= '0';  D2 <= '0';  D1 <= '1';
                    importe <= importe - 1;
                    estado <= CALCAMBIO;
                when others =>
                    estado <= ESPERA;  importe <= "0000";
                    ENTREGAR <= '0';  D5 <= '0';  D2 <= '0';  D1 <= '0';
            end case;
        end if;
    end process;
end architecture ASM;

Notas para el examen: UN solo proceso secuencial con wait until clk='1', con las cuatro salidas escritas en todas las ramas (cada una vale 1 justo el ciclo de su estado: la transición de salida no tiene condición) y importe en std_logic_vector con STD_LOGIC_UNSIGNED — comparas importe >= 6 y sumas/restas sin conversiones, que es como se escribe en los apuntes; el rango se justifica igual (máximo acumulado 5+5=10 en el examen, 4 bits de holgura). El reset síncrono es obligatorio (Tema 3, pág. 30–32): deja ESPERA con importe 0 y las salidas en reposo.

La suma del importe dentro de la rama de ESPERA (en lugar de un proceso contador aparte) es la traducción literal de la caja de acción sobre la ramilla del ASM.

Verificado con GHDL 4.1.0 (--std=08 -fsynopsys) sobre el bloque de arriba, analizado literal, con un testbench que solo observa puertos. Ojo con una sutileza del diseño que la TB caza: la máquina es reactiva — compra en el primer total ≥ 6, y como el parcial previo vale como mucho 5, la suma que cruza el precio está entre 6 y 10: los excesos alcanzables son 0–4 y la rama DEVUELVE_5 es defensiva (no se dispara en ningún escenario legal). Escenarios comprobados: 6 en dos cruces exactos (5+1 y 2+2+2) con cambio 0; 7→D1; 8 (1+2+5)→D2; 9 (2+2+5)→D2+D1; 10 (5+5)→D2+D2; 1 y 2+2 sin llegar al precio (nada se entrega); dos compras seguidas sin reset (el importe queda 0 y la máquina vuelve sola a ESPERA); reset a mitad de la cadena de cambio (corta el segundo D2 y la máquina sigue viva después); y un monitor paralelo que exige que toda salida dure exactamente un ciclo en todo el paseo — 12 secuencias, TEST PASSED. El banco del testbench anterior (con integer range y proceso combinacional) no se ha re-ejecutado: la TB descrita es nueva sobre la estructura nueva.

📚 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 (sistema antirrebote). 📚 Teoría: Tema 2, pág. 50 del PDF «Tema 2 SD-II_20200317.pdf» — registro de E/S en paralelo: entrada de inicialización (Reset).

Errores típicos — P1

Esquema-resumen de la metodología

  1. Separar lo que fija el enunciado de las decisiones de diseño — fija: precio 6, fichas 1/2/5 (una a la vez) y salidas ENTREGAR/D1/D2/D5 de un solo ciclo y seguidas; se decide: contador binario del importe (en vez de codificarlo en los estados), nombres de los 7 estados, desglose goloso del cambio y el reset opcional del VHDL.
  2. Dimensionar el contador con el importe máximo posible — por debajo de 6 solo crece (máx 5) y la ficha que lo alcanza vale como mucho 5 → importe máx 10 → 4 bits (rango 0–15) y exceso máx 4.
  3. Tabular el cambio antes de dibujar — exceso (importe−6) 0–4 → devoluciones golosas en fichas de 5/2/1 con un pulso cada una: 1→D1; 2→D2; 3→D2+D1; 4→D2+D2.
  4. Dibujar la ASM con un bloque por estado y nombres propios — ESPERA, COMPRUEBA, ENTREGA, CALCAMBIO, DEVUELVE_5/2/1; las sumas van en las ramillas de ESPERA (sin estados SUMA aparte) y la decisión IMPORTE≥6 se comparte en COMPRUEBA.
  5. Hacer que cada salida dure 1 ciclo — los estados de salida (ENTREGA, DEVUELVE_x) llevan transición sin condición → exactamente un reloj de pulso por ficha (el mecanismo contador cuenta activaciones).
  6. Cerrar el ciclo de devolución y la puesta a punto — tras cada ficha devuelta se vuelve a CALCAMBIO (IMPORTE←IMPORTE−5/2/1); al ver IMPORTE=0 se va a ESPERA: la máquina queda preparada sola (apartado e) sin reset explícito.
  7. Recorrer un ejemplo sobre el diagrama — 5+5 = 10: ENTREGAR=1, IMPORTE←4 y dos D2 seguidos hasta ESPERA; se comprueban importes y devoluciones.
  8. Traducir a VHDL 1:1 con la ASM — type mis_estados con los nombres de los bloques ASM; UN proceso secuencial con wait until clk='1' y reset síncrono, con el case del ASM y todas las salidas escritas en cada rama (una salida que no se escribe, se memoriza).
  9. Testbenchar los casos borde — 12 secuencias GHDL: precio exacto en dos cruces, excesos 0–4 (la máquina es reactiva: compra al primer total ≥ 6, así que el cruce cae entre 6 y 10), fichas que no llegan al precio, compras consecutivas y reset a mitad de la cadena de cambio; verificar con monitor paralelo que cada salida está a 1 exactamente un ciclo y el recuento de fichas devueltas.

Idea transversal: el importe en un contador (no en los estados) mantiene la ASM en 7 estados pase lo que pase con los importes, y toda salida que debe durar un solo reloj es un estado con transición sin condición; ASM y VHDL son el mismo diseño dicho dos veces, con los mismos nombres estado a estado.


Problema 2 — PicoBlaze para la expendedora (2,5 puntos)

Enunciado del Problema 2, primera parte: sistema hardware con procesador para la expendedora.
Enunciado del Problema 2, primera parte: sistema hardware con procesador para la expendedora.
Enunciado del Problema 2, continuación (viene de la página anterior): incluye la TABLA DE INSTRUCCIONES impresa, referencia obligatoria de los mnemónicos del examen.
Enunciado del Problema 2, continuación (viene de la página anterior): incluye la TABLA DE INSTRUCCIONES impresa, referencia obligatoria de los mnemónicos del examen.

Planteamiento. El mismo problema 1 se resuelve con un PicoBlaze (núcleo KCPSM6 embebido en FPGA): el importe acumulado se guarda en un registro del micro (s0), las fichas se leen de un puerto de entrada (F1=bit0, F2=bit1, F5=bit2) y las salidas se escriben a un puerto de salida (bit0=ENTREGAR, bit1=D5, bit2=D2, bit3=D1). El programa es un bucle que codifica los primeros 5 estados del diagrama ASM obtenido en el problema anterior —en esta guía son los cinco primeros del ASM del apartado 1a: ESPERA, COMPRUEBA, ENTREGA, CALCAMBIO y DEVUELVE_5—. La ROM de programa es EXTERNA al núcleo y debe aparecer en el diagrama.

Datos que fija el enunciado y decisiones de diseño. Fija el enunciado: el baremo (diagrama hardware: 1 p · programa ensamblador debidamente comentado: 1,5 p), que el diagrama detalle «bien» las conexiones, las entradas y salidas y la memoria de programa, que el programa codifique los primeros 5 estados del diagrama ASM obtenido en el problema anterior (cuáles son los 5 primeros los fija el ASM de cada alumno; aquí son ESPERA, COMPRUEBA, ENTREGA, CALCAMBIO y DEVUELVE_5) y la tabla de instrucciones impresa en el propio examen, que es la referencia obligatoria de los mnemónicos: puertos como IN sX,kk / IN sX,(sY) y OUT sX,kk / OUT sX,(sY) (las únicas formas de puerto que imprime la tabla), ADD y ADDC como instrucciones distintas (ídem SUB/SUBC), y saltos JUMP etiq / JUMP (N)Z, etiq / JUMP (N)C, etiq. Decisiones de diseño (no las fija el enunciado): F1/F2/F5 agrupadas en un puerto de entrada H"00" (bits 0-2) y ENTREGAR/D5/D2/D1 en un puerto de salida H"00" (bits 0-3), ambos decodificados con port_id; no usar interrupciones (interrupt_port sin conectar); ROM de programa externa de 1024×18; sin uso de la RAM scratchpad; y la convención de flags que se declara en el programa: COMP/SUB dejan CY=1 si no hay préstamo (la tabla no fija ese convenio).

a) Diagrama hardware (1 p) — descripción detallada

  1. Bloque KCPSM6 (firmcore PicoBlaze, dentro de la FPGA) con sus puertos: clk, reset, input_port(7:0), output_port(7:0), port_id(7:0), read_strobe, write_strobe (en KCPSM6 es output_port_strobe(7:0)), y las líneas de la ROM de programa: program_port_addr(9:0) y program_port_instruction(17:0). La entrada interrupt_port se deja sin usar.
  2. Memoria de programa: ROM 1024 × 18 (block RAM de la FPGA) — NO está dentro del núcleo: direcciones 000H–3FFH contienen las instrucciones de 18 bits. Dibujar SIEMPRE esta ROM junto al núcleo (vale parte del punto).
  3. Puerto de entrada (aislamiento con TEST): las líneas F1, F2, F5 del lector conectadas a los bits 0, 1 y 2 de input_port; el resto de bits a 0. La decodificación de port_id = H"00" con read_strobe habilita ese multiplexor.
  4. Puerto de salida: output_port(7:0) va a registros/latches de salida habilitados por el comparador de port_id = H"00" AND la línea de strobe; de los bits 0-3 salen ENTREGAR, D5, D2 y D1 hacia los mecanismos.
  5. Reloj y reset del núcleo conectados. Sin bus de direcciones externo: el "bus de E/S" del PicoBlaze es input_port/output_port (8 bits) + port_id.
clk (reloj FPGA) reset (sincronizado) KCPSM6 (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: sin uso (no hay FETCH/STORE) interrupt_port: SIN CONECTAR ROM de programa 1024 × 18 block RAM de la FPGA (NO dentro del núcleo) 000H–3FFH: 1024 instrucciones (18 b) el núcleo fetchea aquí cada instrucción interrupt_port sin usar: no hace falta vector de interrupción en 3FFH el PC de 9 bits dirige toda la ROM clk reset dir (9:0) instr (18) Lógica de E/S en la FPGA (fuera del núcleo) el puerto se elige comparando port_id = H"00" con el strobe Lector de monedas F1, F2, F5 fuera de la FPGA F1,F2,F5 (bits 0-2) bits 3-7: a 0 = H"00" MUX 8 b = H"00" (port_id) AND Latch 8 b escritura habilitada bit0 → ENTREGAR bit1 → D5 (ficha 5) bit2 → D2 (ficha 2) bit3 → D1 (ficha 1) 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 (rd=read, wr=write) los EQU del programa fijan el puerto: P_ENT = P_SAL = H"00" · las salidas van a los mecanismos (motor y depósitos) Sin bus de direcciones externo: el "bus de E/S" del PicoBlaze es input_port/output_port (8 b) + port_id. En KCPSM6 la strobe de escritura es output_port_strobe (aquí "wr"): latch habilitado solo si port_id=H"00" AND wr.

Figura: diagrama hardware del PicoBlaze (KCPSM6) con su ROM de programa externa y la lógica de puertos H"00" (apartado a).

📚 Teoría: Tema 4, pág. 11–12 del PDF «Tema 4 SD-II_20220512.pdf» — PicoBlaze: microcontrolador de 8 bits embebido en FPGA, características y diagrama de bloques. 📚 Teoría: Tema 4, pág. 31–34 del PDF «Tema 4 SD-II_20220512.pdf» — puertos de E/S: PORT_ID, strobes de lectura/escritura y conexión de entradas y salidas. 📚 Teoría: Tema 4, pág. 45 y 49 del PDF «Tema 4 SD-II_20220512.pdf» — almacenamiento del programa: bloque RAM 1Kx18 externo y conexión de la ROM del programa.

b) Programa ensamblador comentado (1,5 p)

Problema 2 · Emulador PicoBlaze de la expendedora «ponchis» (5 primeros estados ASM)

El programa de la guía (apartado b) se ensambla y ejecuta tal cual: lee el lector por el puerto de entrada H"00" (bit0=F1, bit1=F2, bit2=F5) y escribe los mecanismos por el puerto de salida H"00" (bit0=ENTREGAR, bit1=D5, bit2=D2, bit3=D1). Estados codificados: ESPERA, COMPRUEBA, ENTREGA, CALCAMBIO y DEVUELVE_5; cada OUT se ejecuta una sola vez por visita al estado (pulso de un ciclo). s0 = importe acumulado, s7 = registro «cero».

Doctrina de flags declarada en el examen (idéntica al emulador de referencia): COMP/SUB dejan CY=1 si NO hay préstamo → JUMP C tras COMP s0,H"06" decide «importe ≥ 6»; ADD/SUB ignoran la CY entrante (solo ADDC/SUBC la usan); TEST deja Z=1 si el bit probado vale 0, por eso los JUMP Z van a la prueba de la ficha siguiente. Los opcodes del listado son los reales de KCPSM6 (18 bits). Ejemplo de la guía: 5+5 → s0=10 → ENTREGAR, s0←4, ruta corta (cambio 4 → salidas a 0, s0←0, ESPERA); forzado s0=11 → ENTREGAR + D5.

El lector mantiene el valor hasta el siguiente IN (una ficha a la vez).
Salida H"00" —
pulsos: ENTREGAR=0 · D5=0 · D2=0 · D1=0
Escrituras OUT (registro)
Listado ensamblado · dirección real ROM (1024×18) · palabra de 18 bits · hex · instrucción

Programa ejecutado sobre un emulador KCPSM con secuencias completas de fichas, ciñéndose a la tabla de instrucciones impresa y a la convención de flags declarada: los pulsos de salida y el estado final coinciden con el ASM del problema 1.

;=====================================================================
; Expendedora "ponchis" (precio 6) - PicoBlaze KCPSM6
; Codifica los 5 primeros estados del ASM del problema 1:
;   ESPERA, COMPRUEBA, ENTREGA, CALCAMBIO, DEVUELVE_5
; Puerto de entrada H"00": bit0=F1, bit1=F2, bit2=F5
; Puerto de salida  H"00": bit0=ENTREGAR, bit1=D5, bit2=D2, bit3=D1
;=====================================================================
P_ENT   EQU H"00"             ; puerto del lector de fichas
P_SAL   EQU H"00"             ; puerto de mecanismos de entrega/devolucion

        ORG H"000"
INICIO: LOAD s0, H"00"        ; s0 = IMPORTE acumulado, empieza a 0
        LOAD s7, H"00"        ; s7 queda siempre a 0 (registro "cero" util)
; ------------- ESTADO 1: ESPERA (leer una ficha) -------------
ESPERA: IN s1, P_ENT          ; leo el lector: F1=bit0, F2=bit1, F5=bit2
        TEST s1, H"01"        ; pruebo F1 (ficha de 1)
        JUMP Z, CHEQ_F2       ; Z=1 -> F1 era 0: pruebo la siguiente ficha
        COMP s7, H"01"        ; 0-1 presta: deja CY=0 (defensivo: la tabla
                              ;  distingue ADD de ADDC; ADD no toma la CY)
        ADD s0, H"01"         ; IMPORTE = IMPORTE + 1
        JUMP COMPRUEBA
CHEQ_F2:TEST s1, H"02"        ; pruebo F2 (ficha de 2)
        JUMP Z, CHEQ_F5       ; Z=1 -> F2 era 0
        COMP s7, H"01"        ; CY=0 (defensivo: ADD suma sin mirar la CY)
        ADD s0, H"02"         ; IMPORTE = IMPORTE + 2
        JUMP COMPRUEBA
CHEQ_F5:TEST s1, H"04"        ; pruebo F5 (ficha de 5)
        JUMP Z, ESPERA        ; no hay ficha insertada: sigo esperando
        COMP s7, H"01"        ; CY=0 (defensivo)
        ADD s0, H"05"         ; IMPORTE = IMPORTE + 5
        JUMP COMPRUEBA
; ------------- ESTADO 2: COMPRUEBA -------------
COMPRUEBA:
        COMP s0, H"06"        ; ¿IMPORTE >= 6? COMP deja CY=1 si no hay presto
        JUMP C, ENTREGA       ; CY=1 -> precio alcanzado o superado
        JUMP ESPERA           ; aun no llega: a por la siguiente ficha
; ------------- ESTADO 3: ENTREGA -------------
ENTREGA:
        LOAD s2, H"01"        ; s2 = 0000_0001: solo ENTREGAR
        OUT s2, P_SAL         ; entrego el producto (una sola pasada = 1 clk)
        SUB s0, H"06"         ; IMPORTE -= 6 exacto: SUB no toma la CY entrada
        JUMP CALCAMBIO
; ------------- ESTADO 4: CALCAMBIO -------------
CALCAMBIO:
        COMP s0, H"05"        ; ¿queda un cambio de al menos 5?
        JUMP C, DEVUELVE_5    ; si -> ESTADO 5
        COMP s0, H"02"        ; (las pruebas >=2 y >=1 corresponden a los
        COMP s0, H"01"        ;  estados DEVUELVE_2 y DEVUELVE_1: el baremo
                              ;  solo codifica los 5 primeros estados)
        LOAD s2, H"00"        ; cambio terminado: apago todas las salidas
        OUT s2, P_SAL         ; (dejan los puertos en reposo)
        LOAD s0, H"00"        ; IMPORTE = 0 para volver a empezar limpia
        JUMP ESPERA           ; maquina preparada de nuevo (apartado e)
; ------------- ESTADO 5: DEVUELVE_5 -------------
DEVUELVE_5:
        LOAD s2, H"02"        ; s2 = 0000_0010: solo D5
        OUT s2, P_SAL         ; devuelvo una ficha de 5 (un ciclo)
        SUB s0, H"05"         ; IMPORTE -= 5 (SUB resta sin tomar la CY)
        JUMP CALCAMBIO        ; y sigo devolviendo o vuelvo a ESPERA

Justificaciones que conviene escribir en el examen: - Cada OUT se ejecuta una sola vez por visita al estado → cada salida dura un ciclo (equivale al bloque ASM de un ciclo). - COMP s0,H"06" deja CY=1 si no hay préstamo, es decir si s0≥6 (es la convención de flags que se declara al programar: la tabla impresa no fija ese convenio) → JUMP C hace la decisión ≥. - La tabla impresa distingue ADD/ADDC y SUB/SUBC: ADD/SUB no toman la CY de entrada (solo la producen, como acarreo o préstamo), y por eso suman y restan exactas. Los COMP s7,H"01" previos a los ADD son defensivos: dejan CY=0 por si se escribiera la variante con acarreo. - La ruta corta de CALCAMBIO (cambio 1, 2, 3 o 4 → DEVUELVE_2/1) no se desarrolla porque el baremo solo codifica los 5 primeros estados; se deja la cadena de COMP y un salto a ESPERA comentándolo, y se pone LOAD s0,H"00" para que el programa parcial no deje importe fantasma en s0.

Ejemplo comprobado en el emulador (5+5): tras la segunda ficha s0=10 → ENTREGA (ENTREGAR=1, s0←4) → CALCAMBIO (4<5) → ruta corta: salidas a 0, s0←0, ESPERA. Una segunda compra 1+5 entrega de nuevo (2 entregas en total, s0 final 0). Ruta forzado s0=11 para probar DEVUELVE_5: ENTREGAR + D5 con s0 final 0. ✔

📚 Teoría: Tema 4, pág. 27–28 del PDF «Tema 4 SD-II_20220512.pdf» — flags ZERO y CARRY en las instrucciones TEST y COMP. 📚 Teoría: Tema 4, pág. 30 del PDF «Tema 4 SD-II_20220512.pdf» — control del flujo: JUMP condicionado a los flags ZERO/CARRY.

Errores típicos — P2

Esquema-resumen de la metodología

  1. Partir de la ASM del problema 1 y ceñirse a sus 5 primeros estados — el baremo codifica solo ESPERA, COMPRUEBA, ENTREGA, CALCAMBIO y DEVUELVE_5 (los 5 primeros del ASM de cada alumno): mantener los nombres exactos y no codificar los estados restantes, dejándolo declarado en comentarios.
  2. Decidir puertos y convenciones antes de programar — puerto de entrada H"00" (bit0=F1, bit1=F2, bit2=F5) y puerto de salida H"00" (bit0=ENTREGAR, bit1=D5, bit2=D2, bit3=D1); ROM externa 1024×18; sin interrupciones ni scratchpad; declarar la convención de flags que la tabla no fija (COMP/SUB dejan CY=1 si no hay préstamo).
  3. Dibujar el hardware con la ROM de programa fuera del núcleo — KCPSM6 con clk, reset, input_port/output_port(7:0), port_id y strobes; ROM 1024×18 (000H–3FFH, instrucciones de 18 bits) siempre junto al núcleo; interrupt_port sin conectar.
  4. Conectar entradas con aislamiento y salidas con latches — F1/F2/F5 a los bits 0–2 de input_port (resto a 0) con el mux habilitado por port_id=H"00" y read_strobe; output_port a latches habilitados por el comparador de port_id AND la línea de strobe; ENTREGAR/D5/D2/D1 salen de los bits 0–3.
  5. Encabezar el programa con ORG y EQU de puertos — nunca direcciones "a dedo"; un encabezado comentado por estado que explique qué y porqué (ahí están los 1,5 puntos).
  6. Codificar las decisiones del estado con TEST y COMP — TEST con máscara de bit (H"01"/H"02"/H"04"): Z=1 significa que el bit probado vale 0 → JUMP Z a la prueba de la ficha siguiente; COMP s0,H"06" + JUMP C para la decisión ≥6 con la convención declarada.
  7. Usar solo los mnemónicos de la tabla impresa — IN/OUT únicamente en forma kk o (sY); ADD y ADDC son instrucciones distintas (ídem SUB/SUBC): ADD/SUB no toman la CY de entrada y por eso suman y restan exactas; los COMP s7,H"01" previos son defensivos (dejan CY=0).
  8. Hacer que cada OUT se ejecute una sola vez por visita al estado — un OUT = un pulso de un ciclo, equivalente al bloque ASM de un ciclo; en la ruta corta de CALCAMBIO apagar salidas con OUT s2,H"00" y limpiar importe con LOAD s0,H"00" para no dejar importe fantasma.
  9. Ejecutar el programa en un emulador KCPSM — 5+5 (s0=10: ENTREGAR, s0←4, ruta corta), segunda compra (2 entregas, s0 final 0) y s0=11 forzado para ver DEVUELVE_5 (ENTREGAR + D5): los pulsos de salida coinciden con la ASM del problema 1.

Idea transversal: la tabla de instrucciones impresa del examen es la única referencia de mnemónicos (IN/OUT kk, ADD≠ADDC, TEST con Z invertido) y el programa es literalmente la ASM del problema anterior: mismos estados con mismos nombres, un OUT por bloque de un ciclo, y lo que el baremo no pide se declara en comentarios en vez de inventárselo.


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

Enunciado íntegro del Problema 3 (mapa de memoria con bus de datos de 16 bits). Es 100 % textual: no hay figura de mapa; el diagrama hay que dibujarlo.
Enunciado íntegro del Problema 3 (mapa de memoria con bus de datos de 16 bits). Es 100 % textual: no hay figura de mapa; el diagrama hay que dibujarlo.

Planteamiento. El bus de datos tiene 16 bits y hay 256K posiciones: cada posición es una palabra de 16 bits y el espacio de 2¹⁸ = 262 144 posiciones exige 18 líneas de dirección, A17…A0. Se colocan E/S1 (32K), E/S2 (64K) y RAM (48K) seguidos desde 0h en ese orden, y la PROM de 64K anclada al final del mapa; eso deja un hueco de 48K entre la RAM y la PROM. Con los CI disponibles (PROM 32K×16, RAM 16K×8) hay que hacer expansión de palabras y de bits y generar los CS con la polaridad de cada bloque.

Datos que fija el enunciado y decisiones de diseño. Fija el enunciado: bus de datos de 16 bits, espacio de direccionamiento máximo de 256K posiciones, los módulos E/S1 (32K), E/S2 (64K) y RAM (48K) seguidos y en ese orden desde la posición inicial 0h, la PROM de 64K que termina al final del mapa, las polaridades de control (E/S1 y E/S2: CE y RW activas a nivel bajo; RAM: CE alto y RW bajo; PROM: CE alto, sin mención de RW), los CI disponibles (PROM 32K×16, RAM 16K×8) y el baremo: tabla del mapa 1 p · diagrama lógico simplificado 1 p · módulo VHDL de decodificación 1,5 p. El hueco libre de 48K entre la RAM y la PROM no está impreso: se deduce de la colocación pedida (32K+64K+48K = 144K desde 0h y la PROM acaba en 3FFFFH). El mapa queda unívocamente fijado por el enunciado: no hay decisiones de diseño de relevancia, solo la forma de escribir el decodificador (que se comenta tras el VHDL).

Datos de partida

a) Tabla del mapa de memoria (1 p)

Problema 3 · Mapa de memoria interactivo (256K posiciones × 16 bits)

Espacio 00000H–3FFFFH (2¹⁸ → 18 líneas de dirección A17–A0; el bus de datos de 16 bits no reduce el espacio) · orden E/S-1 → E/S-2 → RAM → hueco → PROM · E/S: CS̅ y RW̅ a nivel BAJO · RAM/PROM: CE a nivel ALTO · la decodificación usa solo las líneas altas A17–A14

⚠ Trampa del problema: E/S-1 mide solo 32K, así que E/S-2 (64K) queda desalineado (empieza en 08000H, cruza la frontera de A16) y su CS necesita A15 además de A17,A16: CS_ES2 = A17 + (A16 XNOR A15). Escribe la dirección y mira el CS que resulta activo y su valor.

RAM-A1: 16K×8 → D7–D0 · grupo A 18000H–1BFFFH · CS = CS_RAM_A (ALTO) · A13–A0 A1→D7–D0 RAM-A2: 16K×8 → D15–D8 · grupo A 18000H–1BFFFH · CS = CS_RAM_A (ALTO) · A13–A0 A2→D15–D8 RAM-B1: 16K×8 → D7–D0 · grupo B 1C000H–1FFFFH · CS = CS_RAM_B (ALTO) · A13–A0 B1→D7–D0 RAM-B2: 16K×8 → D15–D8 · grupo B 1C000H–1FFFFH · CS = CS_RAM_B (ALTO) · A13–A0 B2→D15–D8 RAM-C1: 16K×8 → D7–D0 · grupo C 20000H–23FFFH · CS = CS_RAM_C (ALTO) · A13–A0 C1→D7–D0 RAM-C2: 16K×8 → D15–D8 · grupo C 20000H–23FFFH · CS = CS_RAM_C (ALTO) · A13–A0 C2→D15–D8 PROM-0: 32K×16 · 30000H–37FFFH · CS = CS_PROM0 (ALTO) · A17A16A15 = 110 · A14–A0 PROM-0 · 32K×16 30000H–37FFFH PROM-1: 32K×16 · 38000H–3FFFFH · CS = CS_PROM1 (ALTO) · A17A16A15 = 111 · A14–A0 PROM-1 · 32K×16 38000H–3FFFFH E/S-1 · 32K (CS̅ BAJO) E/S-2 · 64K desalineado (CS̅ BAJO) RAM 48K×16 · 6 CI 16K×8 (CE ALTO) hueco 48K · sin decodificar PROM 64K×16 · 2 CI 32K×16 (CE ALTO) grupo A grupo B grupo C 00000 07FFF 08000 17FFF 18000 23FFF 24000 2FFFF 30000 3FFFF 1BFFF 1C000 1FFFF 20000 37FFF 38000
Pulsa Enter o Decodificar · el marcador naranja señala la posición sobre el mapa a escala (00000H–3FFFFH)

Mini-examen · rellena con rango hex (5 dígitos), nombre de CS o nº — pistas basadas en los «errores típicos — P3» de la guía

Aciertos: —

Colocación pedida, comprobada: 32K+64K+48K = 144K desde 0h; la PROM de 64K acaba en 3FFFFH → empieza en 0x40000−0x10000 = 0x30000. Hueco = 0x30000−0x24000 = 0xC000 = 48K. Suma total = 262 144 = 256K (encaja exacto).

Módulo Tamaño Inicial hex Final hex CE RW
E/S1 32K 00000H 07FFFH BAJO BAJO
E/S2 64K 08000H 17FFFH BAJO BAJO
RAM 48K 18000H 23FFFH ALTO BAJO
Hueco libre 48K 24000H 2FFFFH — —
PROM 64K 30000H 3FFFFH ALTO —

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

Bloque CI disponible Palabras Bits Nº CI
PROM 64K×16 PROM 32K×16 64K/32K = 2 16/16 = 1 2 (en cascada)
RAM 48K×16 RAM 16K×8 48K/16K = 3 16/8 = 2 6 (3 grupos de 2 en paralelo)
E/S1 / E/S2 módulos hechos — — 1 + 1

Detalle por CI (nivel circuito, lo que exige el diagrama):

CI Direcciones Selección (CE) Líneas internas de dir.
E/S1 00000H–07FFFH BAJO: A17A16A15 = 000 A14–A0
E/S2 08000H–17FFFH BAJO: A17=0 y A16≠A15 ver nota de alineación
RAM-A1,RAM-A2 (D7–D0 y D15–D8) 18000H–1BFFFH ALTO: A17..A14 = 0110 A13–A0
RAM-B1,RAM-B2 1C000H–1FFFFH ALTO: A17..A14 = 0111 A13–A0
RAM-C1,RAM-C2 20000H–23FFFH ALTO: A17..A14 = 1000 A13–A0
PROM-0 30000H–37FFFH ALTO: A17A16A15 = 110 A14–A0
PROM-1 38000H–3FFFFH ALTO: A17A16A15 = 111 A14–A0

Trampa del problema: E/S1 mide solo 32K, así que E/S2 (64K) no queda alineada a frontera de 64K (empieza en 08000H): cruza la frontera de A16. Su selección necesita A15 además de A17,A16 (sectores de 32K nº1 y nº2). Para que el módulo de 64K (16 líneas internas de dirección) funcione, conecta sus entradas de dirección A14'–A0' a A14–A0 del CPU y su MSB A15' a A16 del CPU (mientras su CS está activo esa correspondencia es biyectiva sobre el rango 08000H–17FFFH). Escríbelo en el examen: demuestra que entiendes por qué la alineación importa.

📚 Teoría: Tema 5, pág. 32 del PDF «Tema 5 SD-II_20230215.pdf» — capacidad direccionable: m líneas del bus de direcciones. 📚 Teoría: Tema 5, pág. 33 del PDF «Tema 5 SD-II_20230215.pdf» — ejemplo de diseño de un mapa de memoria con RAM, ROM y E/S. 📚 Teoría: Tema 1, pág. 53–55 del PDF «Tema 1 SD-II_20200206.pdf» — memorias ROM/FLASH: organización en palabras de m bits (128K×8).

b) Diagrama lógico simplificado (1 p) — ecuaciones y descripción

Partición de las 18 líneas: los bloques de 32K consumen A14–A0 y los de 16K consumen A13–A0; la decodificación usa las 4 líneas altas A17–A14. Ecuaciones (nivel alto activo salvo donde se indica lo contrario; la barra sobre el término es el inversor correspondiente):

En el hueco 24000H–2FFFFH (combinaciones A17A16A15=100 con A14=1, y 101) ninguna salida se activa: no hay que decodificarlo.

CPU (bus de datos de 16 bits) Bus: A17–A0 (18) · D15–D0 (16) · R/W‾ A17–A14 van también al decodificador los buses A y D salen del bloque por arriba (una línea simple por cada bus, etiquetada) DECODIFICADOR · usa A17–A14 · NOT = inversor CS_ES1 (BAJO) = NOT (A17 + A16 + A15) CS_ES2 (BAJO) = A17 + (A16 XNOR A15) CS_RAM_A (ALTO) = NOT A17 · A16 · A15 · NOT A14 CS_RAM_B (ALTO) = NOT A17 · A16 · A15 · A14 CS_RAM_C (ALTO) = A17 · NOT A16 · NOT A15 · NOT A14 CS_PROM0 (ALTO) = A17 · A16 · NOT A15 → 30000H–37FFFH CS_PROM1 (ALTO) = A17 · A16 · A15 → 38000H–3FFFFH Hueco 24000H–2FFFFH: ninguna salida activa (no se decodifica) E/S-1 · 32K · 00000H–07FFFH CS (BAJO) ← CS_ES1 · RW‾ (BAJO) direcciones A14–A0 · datos D15–D0 E/S-2 · 64K · 08000H–17FFFH CS (BAJO) ← CS_ES2 · RW‾ (BAJO) dir: A14′–A0′←A14–A0 · A15′←A16 desalineado: cruza la frontera de A16 RAM 48K×16 · 18000H–23FFFH · 6 CI de 16K×8 Grupo A · 18000H–1BFFFH · CS = CS_RAM_A (ALTO) RAM-A1 (D7–D0) + RAM-A2 (D15–D8) · A13–A0 comunes Grupo B · 1C000H–1FFFFH · CS = CS_RAM_B (ALTO) RAM-B1 (D7–D0) + RAM-B2 (D15–D8) · A13–A0 comunes Grupo C · 20000H–23FFFH · CS = CS_RAM_C (ALTO) RAM-C1 (D7–D0) + RAM-C2 (D15–D8) · A13–A0 comunes hueco 24000H–2FFFFH (48K) sin decodificar: ningún CS activo PROM 64K×16 · 30000H–3FFFFH · 2 CI en cascada CE ALTO · sin RW · los 2 CI reciben A14–A0 y D15–D0 PROM-0 (32K×16) 30000H–37FFFH CS = CS_PROM0 (ALTO) PROM-1 (32K×16) 38000H–3FFFFH CS = CS_PROM1 (ALTO) A14–A0 D15–D0 D15–D0 A14–A0 · D15–D0 A17–A0 (18) D15–D0 R/W‾ A17–A14 CS_ES1 (BAJO) CS_ES2 (BAJO) Notas: punto = unión de cables; cruce de cables sin punto = sin conexión. Cada CS entra por el borde izquierdo de su bloque; los grupos de RAM y las PROM indican su CS dentro. A y D del CPU alimentan cada bloque por su borde derecho (RAM: A13–A0 y D15–D0; PROM: A14–A0 y D15–D0 por el borde inferior). R/W‾ (rojo) solo a E/S-1, E/S-2 y RAM. NOT(X) = X invertida (equivale a las barras del enunciado). La PROM no lleva señal RW. El hueco 24000H–2FFFFH no se decodifica: ninguna salida activa.

Figura: diagrama lógico simplificado del apartado b (mapa del apartado a y decodificación con las ecuaciones de arriba).

Dibujar: CPU con bus A17–A0 y bus de datos de 16 bits D15–D0 y línea R/W̄; A13–A0 a las RAM, A14–A0 a E/S1 y a las PROM (a E/S2 según la nota anterior); bloques decodificadores con las ecuaciones de arriba; cada CS a su CI/grupo; R/W̄ de la CPU directa a las patillas RW̅ de E/S1, E/S2 y los 6 RAM (la PROM no tiene RW). En cada grupo de 2 RAM, un CI conduce D7–D0 y el otro D15–D8 (comparten direcciones y CS).

📚 Teoría: Tema 5, pág. 34–35 del PDF «Tema 5 SD-II_20230215.pdf» — condiciones de habilitación de los bloques del mapa según las líneas de dirección. 📚 Teoría: Tema 1, pág. 3–5 del PDF «Tema 1 SD-II_20200206.pdf» — decodificador completo: n entradas y 2ⁿ salidas (minitérminos).

c) Módulo VHDL de la decodificación para FPGA (1,5 p)

Analizado con GHDL y simulado sobre el mapa completo: el módulo solo recibe A(17 downto 14), así que sus 16 patrones de entrada cubren las 262 144 direcciones (cada patrón = un bloque de 16K): cada CS activo exactamente en su rango, ningún solapamiento, hueco sin activar. Bloque intacto en el pase de estilo (el when/else del Tema 5 pág. 36–37 es el estilo de los apuntes) y barrido re-ejecutado en GHDL --std=08 -fsynopsys (12/11): ES1 en 2 patrones, ES2 en 4, cada CS_RAM en 1, cada CS_PROM en 2, hueco en 3 (24000H–2FFFFH) y 0 solapes:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity Decodificador_Map is
    port (
        A       : in  std_logic_vector(17 downto 14);  -- lineas altas de direccion
        CS_ES1  : out std_logic;                       -- E/S1: activa a nivel BAJO
        CS_ES2  : out std_logic;                       -- E/S2: activa a nivel BAJO
        CS_RAM  : out std_logic_vector(2 downto 0);    -- RAM (3 grupos de 16K): ALTO
        CS_PROM : out std_logic_vector(1 downto 0)     -- PROM (2 CI de 32K): ALTO
    );
end entity Decodificador_Map;

architecture Behaviour of Decodificador_Map is
begin
    -- E/S1: 00000H-07FFFH   (A17 A16 A15 = 0 0 0)          CS activo a nivel BAJO
    CS_ES1 <= '0' when A(17 downto 15) = "000" else '1';

    -- E/S2: 08000H-17FFFH   (A17=0 y A16 /= A15: sectores 001 y 010)  CS BAJO
    CS_ES2 <= '0' when (A(17) = '0' and (A(16) xor A(15)) = '1') else '1';

    -- RAM 48K (CE ALTO): 3 grupos de 16K, uno por bit de CS_RAM
    CS_RAM(0) <= '1' when A = "0110" else '0';   -- RAM-A 18000H-1BFFFH
    CS_RAM(1) <= '1' when A = "0111" else '0';   -- RAM-B 1C000H-1FFFFH
    CS_RAM(2) <= '1' when A = "1000" else '0';   -- RAM-C 20000H-23FFFH

    -- PROM 64K (CE ALTO) al final del mapa: 2 CI de 32K, uno por bit de CS_PROM
    CS_PROM(1) <= '1' when A(17 downto 15) = "110" else '0';  -- PROM-0 30000H-37FFFH
    CS_PROM(0) <= '1' when A(17 downto 15) = "111" else '0';  -- PROM-1 38000H-3FFFFH
end architecture Behaviour;

Nota VHDL: si el profesor prefiere ver las ecuaciones como sumas de productos, se puede escribir el mismo decodificador como ecuaciones booleanas directas sobre A(17..14) (CS_RAM(0) <= (not A(17)) and A(16) and A(15) and not A(14); …); la simulación es idéntica.

📚 Teoría: Tema 5, pág. 36–37 del PDF «Tema 5 SD-II_20230215.pdf» — descripción VHDL de la decodificación del mapa de memoria (dos versiones). 📚 Teoría: Tema 1, pág. 33–34 del PDF «Tema 1 SD-II_20200206.pdf» — decodificador de 3 a 8 líneas en VHDL, con línea de enable.

Errores típicos — P3

Esquema-resumen de la metodología

  1. Derivar las líneas de dirección del nº de posiciones — 256K posiciones de palabra de 16 bits → 2¹⁸ = 18 líneas A17–A0 y direcciones hex de 5 dígitos, 00000H–3FFFFH; el bus de datos de 16 bits no reduce el espacio de direcciones.
  2. Colocar los bloques donde el enunciado los fija — E/S1 (32K), E/S2 (64K) y RAM (48K) seguidos y en ese orden desde 00000H; la PROM de 64K anclada al final → empieza en 0x40000−0x10000 = 30000H y acaba en 3FFFFH.
  3. Comprobar con sumas y deducir el hueco — 32K+64K+48K = 144K terminan en 23FFFH; el hueco 24000H–2FFFFH (0x30000−0x24000 = 48K) no está impreso, se deduce, y el total encaja exacto en 256K.
  4. Rellenar la tabla con inicial, final y polaridades por bloque — E/S1 y E/S2: CE̅ y RW̅ nivel BAJO; RAM: CE ALTO y RW̅ BAJO; PROM: CE ALTO, sin RW; el hueco libre no se decodifica.
  5. Detectar la desalineación antes de elegir las CS — E/S1 mide solo 32K, así que E/S2 (64K) empieza en 08000H sin alinear a frontera de 64K y cruza A16: se selecciona con A17=0 y A16≠A15, y al módulo de 64K hay que conectarle su MSB A15' a A16 del CPU.
  6. Contar los CI con expansión de palabras × bits — PROM 64K×16: 2 CI de 32K×16 en cascada (los distingue A15); RAM 48K×16: 3 grupos de 16K con 2 RAM 16K×8 en paralelo cada uno (uno D7–D0, otro D15–D8) → 6 CI, no 3.
  7. Decodificar solo con las líneas altas A17–A14 y la polaridad de cada bloque — CS_ES1 (BAJO) = A17+A16+A15; CS_ES2 (BAJO) = A17+(A16 XNOR A15); cada grupo de RAM, producto de 4 términos (A17..A14 = 0110/0111/1000); cada PROM, producto de 3 (110/111).
  8. Dibujar el diagrama lógico completo — CPU con A17–A0, D15–D0 y R/W̄; direcciones por bloque (A14–A0 a E/S1 y PROM, A13–A0 a las RAM, E/S2 según la nota de alineación); cada CS a su CI/grupo; R/W̄ directa a E/S1, E/S2 y las 6 RAM (la PROM no lleva RW).
  9. Escribir el decodificador VHDL sobre A(17 downto 14) y barrer todo el mapa — una expresión por CS (o suma de productos equivalente); GHDL simula las 262 144 direcciones: cada CS activa exactamente en su rango, ningún solape y ninguna señal en el hueco.

Idea transversal: el orden impuesto y el anclaje de la PROM al final fijan el mapa sin decisiones — rangos y hueco se deducen sumando en hex, no a ojo; la alineación decide qué líneas seleccionan cada bloque (E/S2 desalineado es la trampa) y el decodificador se valida barriendo todo el espacio de direcciones en busca de solapes y fronteras, no solo direcciones de ejemplo.

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.