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

Guía modelo para preparar la convocatoria de nov-dic 2026. El examen tiene 3 problemas: vagoneta sobre raíles ASM + VHDL (4 p), CPU von Neumann — microoperaciones + unidad de control (4 p) y mapa de memoria de 64K posiciones con bus de 8 bits (2 p).

Estado de esta guía: 3 de 3 problemas publicados y verificados: vagoneta ASM + VHDL (P1, doble pasada GHDL estricto), microoperaciones y mapa.

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).

Verificación de esta guía: los dos módulos VHDL (control de la vagoneta y decodificador del mapa) están analizados y simulados con GHDL 4.1.0 --std=08 -fsynopsys. El controlador de la vagoneta (reescrito al estilo de los apuntes: proceso único con wait until clk='1', reset síncrono, contador en vectores) pasa un testbench que solo observa puertos: con la pre-escala reducida PRE=9 (10 flancos/tick) la espera de E mide exactamente (PRE+1)·150 + 2 = 1502 flancos las dos veces que se dispara — sin restos del contador tras un reset a mitad—; a escala real (PRE = 999.999) eso son 150.000.002 flancos = 6,00000008 s (150.000.000 pulsos de cuenta + 2 de latencia de registro; el barrido de linealidad en cuatro pre-escalas del TB anterior no se ha re-ejecutado — ver notas). El decodificador del mapa se simuló barriendo las 64 combinaciones de A15–A10 (= todas las clases de dirección de 16 bits): las 9 señales correctas, cero solapes. La secuencia de microoperaciones del problema 2 se ejecutó sobre un modelo Python de la unidad de procesado con un programa test (LDAC/ADD/MUL3/SUBR/RETS/STAC/JUMP Z tomado y no tomado/STOP): resultados, Z y PC correctos paso a paso. Las cuentas hex están comprobadas programáticamente.

Supuestos declarados (figuras)

  1. P1: el enunciado en texto contiene todo; la figura solo muestra la vagoneta sobre los raíles con la rueda izquierda y su leva frente al sensor R. El texto no nombra la señal que hace girar la rueda (la tracción I/D desplaza la vagoneta, no gira la rueda): la llamaremos GIZQ / GDER y se declara en el examen. Si tu figura usa otros nombres, renombra — la estructura no cambia.
  2. P2: la figura de la Unidad de Procesado sí está incrustada en el PDF (jpeg en la pág. 2, idéntica píxel a píxel a la del examen de junio-2024): los pares EN/C concretos (EN2–EN11, C2–C14) y los cableados de la ALU están en el propio apartado del Problema 2, con los supuestos que hay que escribir en el examen (L transparente, captura ALU→AC, flag Z, pulso WE̅ a la memoria).
  3. P3: el texto da todos los datos. "Centro del mapa" = mitad de 64K = 8000H. Los módulos E/S son circuitos ya hechos de 2K×8 con sus entradas CE/WE; no se construyen con CIs de memoria.

Problema 1 — Vagoneta sobre raíles: ASM + VHDL (4 puntos)

Planteamiento. Es una ASM con la vagoneta parada esperando orden (único punto donde mandan los pulsadores, porque el enunciado dice que las pulsaciones con la vagoneta en movimiento se ignoran). E lanza una cuenta de 6 s y después un giro de la rueda izquierda a la izquierda; G lanza el mismo giro a la derecha (sin cuenta: el enunciado solo menciona los 6 s en E); F y H desplazan la vagoneta mientras se mantienen a nivel. Un giro "completo" exige dos estados porque el sensor R vale 1 en reposo: primero hay que alejar la leva del sensor (esperar R=0) y luego acercarla hasta volver a ver R=1. Los 6 s se generan con reloj de 25 MHz mediante dos contadores en cascada.

Baremo del enunciado: a) diagrama ASM con cálculos de la espera: 2,5 p · b) código VHDL del diagrama: 1,5 p.

Cálculo de la espera de 6 s a 25 MHz (imprescindible, va en el apartado a)

6 s × 25.000.000 pulsos/s = 150.000.000 pulsos

Se descompone en dos contadores en cascada:

Etapa Módulo Cuenta con Resultado Bits necesarios
Pre-escala MOD-1.000.000 25 MHz 25 Hz (un pulso cada 40 ms) 20 (2²⁰ = 1.048.576 ≥ 10⁶)
Contador de ticks MOD-150 25 Hz 150 × 40 ms = 6,00 s justos 8 (2⁸ = 256 ≥ 150)

Comprobación: 1.000.000 × 150 = 150.000.000 ✔ y 150·10⁶ / 25·10⁶ = 6 s ✔. Los contadores solo cuentan mientras la ASM está en ESPERA_6S (habilitación implícita por el estado) y se limpian al salir de ese estado. El nivel T (terminal de cuenta) pasa a 1 tras 150.000.000 pulsos y provoca la salida del estado.

Alternativa equivalente y válida: un único contador MOD-150.000.000 de 28 bits (2²⁸ = 268.435.456 ≥ 150·10⁶). La cascada 10⁶ × 150 es la que se usa en clase.

📚 Teoría: Tema 2, pág. 56–58 del PDF «Tema 2 SD-II_20200317.pdf» — contador síncrono con habilitación y borrado; asociación de contadores para obtener mayor módulo y, en particular, la asociación síncrona que «emplea las entradas y salidas de habilitación de cuenta» (igual que aquí: el contador de ticks avanza solo cuando la pre-escala completa su ciclo, con los dos flancos de reloj aplicados simultáneamente).

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

Bloques ASM (uno por estado; entre corchetes las salidas activas del estado; "sin transición" = permanecer; T = fin de los 6 s):

# Estado (bloque ASM) Salida Decisiones → siguiente estado
1 PARADA (espera de orden) — E=1 → ESPERA_6S; F=1 → MUEVE_IZQ; G=1 → (R=1: GDER_ALEJA · R=0: GDER_ACERCA); H=1 → MUEVE_DER
2 ESPERA_6S — T=1 → (R=1: GIZ_ALEJA · R=0: GIZ_ACERCA). E/F/G/H ignoradas
3 MUEVE_IZQ I F=1 → quedarse; F=0 → PARADA
4 MUEVE_DER D H=1 → quedarse; H=0 → PARADA
5 GIZ_ALEJA GIZQ R=1 → quedarse (alejar la leva); R=0 → GIZ_ACERCA
6 GIZ_ACERCA GIZQ R=0 → quedarse; R=1 → PARADA (vuelta completa / reposo alcanzado)
7 GDER_ALEJA GDER R=1 → quedarse; R=0 → GDER_ACERCA
8 GDER_ACERCA GDER R=0 → quedarse; R=1 → PARADA
stateDiagram-v2 [*] --> PARADA : reset PARADA --> ESPERA_6S : E=1 PARADA --> MUEVE_IZQ : F=1 PARADA --> MUEVE_DER : H=1 PARADA --> GDER_ALEJA : G=1 y R=1 PARADA --> GDER_ACERCA : G=1 y R=0 ESPERA_6S --> GIZ_ALEJA : T=1 y R=1 ESPERA_6S --> GIZ_ACERCA : T=1 y R=0 MUEVE_IZQ --> PARADA : F=0 MUEVE_DER --> PARADA : H=0 GIZ_ALEJA --> GIZ_ACERCA : R=0 GIZ_ACERCA --> PARADA : R=1 GDER_ALEJA --> GDER_ACERCA : R=0 GDER_ACERCA --> PARADA : R=1

Claves del planteamiento (lo que puntúa):

📚 Teoría: Tema 3, pág. 15–19 del PDF «Tema 3 SD-II_20200413.pdf» — bloques de un diagrama ASM: cajas de estado (rectangulares, comportamiento Moore, incluyen las salidas de control), cajas de selección (rombo con dos salidas, deciden el estado siguiente), cajas de condición (esquinas redondeadas, Mealy) y bloque ASM: «todos los elementos existentes entre dos cajas de estado, incluyendo únicamente la primera», es decir todas sus operaciones se ejecutan en un mismo ciclo de reloj.

Ejemplo de recorrido: reposo con rueda en reposo →(E) ESPERA_6S[6 s] →(T,R=1) GIZ_ALEJA[GIZQ=1 hasta R=0] → GIZ_ACERCA[GIZQ=1 hasta R=1: una vuelta completa] → PARADA →(F mantenido) MUEVE_IZQ[I=1 mientras F=1] →(suelto F) PARADA.

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

Verificado con GHDL 4.1.0 (--std=08 -fsynopsys) sobre el bloque de arriba, analizado literal: el testbench observa solo puertos y maneja R como la leva del sensor (nivel). Con los generic reducidos PRE=9 y G_TICKS=150 (10 flancos por tick), la espera medida es exactamente 1502 flancos = (PRE+1)·150 + 2, igual en la primera y en la segunda espera (el contador se limpia al salir: sin restos), incluso tras un reset a mitad de la cuenta. A escala real (PRE=999.999): 150.000.002 flancos, la cuenta exacta de 150.000.000 pulsos más 2 relojes (80 ns) de latencia de los registros. Comprobado además: F pulsada durante ESPERA_6S no activa I (pulsación ignorada), el giro E desconecta R al empezar y termina junto al reposo (ALEJA→ACERCA, una vuelta completa, GIZQ sin cortes), G desde fuera de reposo gira a la derecha hasta alcanzarlo sin espera de 6 s, G desde reposo da la vuelta completa por la derecha, F/H paran al cesar la pulsación, durante reset=1 las cuatro salidas están en reposo, e I con D y GIZQ con GDER nunca suben a la vez. El banco anterior (modelo físico de leva de 16 fases y comprobación de linealidad en cuatro pre-escalas) no se ha re-ejecutado contra esta estructura — registrado en las notas de elaboración.

📚 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: «no es necesario llegar a una descripción como una estructura de componentes»; se describe el comportamiento «como si fuera un diagrama de estados», definiendo en cada estado las transiciones y transferencias, y añadiendo reloj y reset a las señales de la tarjeta identificativa. 📚 Teoría: Tema 3, pág. 33–34 del PDF «Tema 3 SD-II_20200413.pdf» — simulación en VHDL usando parametrización: para poder simular, «el valor de la cuenta máxima del contador se ha reducido» (aquí son los generic G_PRE_MAX y G_TICKS).

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

entity Vagoneta is
    generic (
        G_PRE_MAX : integer := 999_999;  -- pre-escala: cuenta 0..999.999 (MOD-1e6, 20 bits)
        G_TICKS   : integer := 150       -- ticks de 25 Hz: 150 x 40 ms = 6 s (MOD-150, 8 bits)
    );
    port (
        clk, reset   : in  std_logic;
        E, F, G, H   : in  std_logic;              -- pulsadores (nivel alto mientras se pulsan)
        R            : in  std_logic;              -- 1 = rueda izquierda en reposo
        I, D         : out std_logic;              -- traccion vagoneta: izquierda / derecha
        GIZQ, GDER   : out std_logic               -- giro de la rueda: izquierda / derecha
    );
end entity Vagoneta;

architecture ASM of Vagoneta is
    -- nombres de estado = nombres de los bloques del diagrama ASM
    type mis_estados is (PARADA, ESPERA_6S, MUEVE_IZQ, MUEVE_DER,
                         GIZ_ALEJA, GIZ_ACERCA, GDER_ALEJA, GDER_ACERCA);
    signal estado : mis_estados;

    -- temporizador de 6 s (modulo CTR del enunciado: solo corre en ESPERA_6S y se
    -- limpia al salir). Vector de 20 bits (999.999 < 1.048.575; la comparacion es por
    -- IGUALDAD, no suma+1: sin overflow)
    constant pre_bit : integer := 20;
    signal pre   : std_logic_vector(pre_bit-1 downto 0);  -- 25 MHz -> 25 Hz
    signal ticks : std_logic_vector(7 downto 0);          -- 150 x 40 ms = 6 s
    signal t     : std_logic;                             -- 6 s transcurridas
begin
    ------- proceso secuencial UNICO: contador del CTR + estado + salidas -------
    process
    begin
        wait until clk = '1';
        if reset = '1' then
            estado <= PARADA;
            I <= '0';  D <= '0';  GIZQ <= '0';  GDER <= '0';
            pre <= (others => '0');  ticks <= (others => '0');  t <= '0';
        else
            ------- el CTR de 6 s: habilitado solo en ESPERA_6S -------
            if estado /= ESPERA_6S then
                pre <= (others => '0');  ticks <= (others => '0');  t <= '0';
            elsif pre = G_PRE_MAX then
                pre <= (others => '0');
                if ticks = G_TICKS - 1 then t <= '1';
                else                        ticks <= ticks + 1;
                end if;
            else
                pre <= pre + 1;
            end if;
            ------- el ASM: salidas de traccion/giro dentro de cada estado -------
            case estado is
                when PARADA =>                        -- vagoneta parada: unico estado
                    I <= '0';  D <= '0';  GIZQ <= '0';  GDER <= '0';
                    if E = '1' then         estado <= ESPERA_6S;   -- donde mandan los botones
                    elsif F = '1' then      estado <= MUEVE_IZQ;
                    elsif G = '1' then
                        if R = '1' then     estado <= GDER_ALEJA;  -- en reposo: vuelta completa
                        else                estado <= GDER_ACERCA; -- fuera: hasta alcanzar reposo
                        end if;
                    elsif H = '1' then      estado <= MUEVE_DER;
                    end if;
                when ESPERA_6S =>                     -- E: cuenta de 6 s; botones ignorados
                    I <= '0';  D <= '0';  GIZQ <= '0';  GDER <= '0';
                    if t = '1' then
                        if R = '1' then     estado <= GIZ_ALEJA;
                        else                estado <= GIZ_ACERCA;
                        end if;
                    end if;
                when MUEVE_IZQ =>                     -- F a nivel: se para al cesar la pulsacion
                    I <= '1';  D <= '0';  GIZQ <= '0';  GDER <= '0';
                    if F = '0' then         estado <= PARADA;
                    end if;
                when MUEVE_DER =>                     -- H a nivel
                    I <= '0';  D <= '1';  GIZQ <= '0';  GDER <= '0';
                    if H = '0' then         estado <= PARADA;
                    end if;
                when GIZ_ALEJA =>                     -- rueda en reposo: primero ALEJARLA del sensor
                    I <= '0';  D <= '0';  GIZQ <= '1';  GDER <= '0';
                    if R = '0' then         estado <= GIZ_ACERCA;
                    end if;
                when GIZ_ACERCA =>                    -- ACERCARLA: termina al ver R de nuevo
                    I <= '0';  D <= '0';  GIZQ <= '1';  GDER <= '0';
                    if R = '1' then         estado <= PARADA;
                    end if;
                when GDER_ALEJA =>
                    I <= '0';  D <= '0';  GIZQ <= '0';  GDER <= '1';
                    if R = '0' then         estado <= GDER_ACERCA;
                    end if;
                when GDER_ACERCA =>
                    I <= '0';  D <= '0';  GIZQ <= '0';  GDER <= '1';
                    if R = '1' then         estado <= PARADA;
                    end if;
                when others =>
                    estado <= PARADA;
                    I <= '0';  D <= '0';  GIZQ <= '0';  GDER <= '0';
            end case;
        end if;
    end process;
end architecture ASM;

Notas para el examen: UN solo proceso secuencial con wait until clk='1' — dentro, primero el contador del módulo CTR del enunciado (habilitado solo en ESPERA_6S, limpio al salir) y después el case del ASM con las cuatro salidas de tracción/giro escritas en todas las ramas (así ninguna se queda "memorizada" al cambiar de estado). El contador en std_logic_vector con STD_LOGIC_UNSIGNED y comparación por igualdad es lo de los apuntes; reset síncrono obligatorio (Tema 3, pág. 30–32). Los generic son la parametrización de las págs. 33–34 para poder simular.

En el examen escribe las constantes directamente (if pre = 999_999, if ticks = 149). El estado PARADA tras reset deja la máquina lista (la figura arranca con leva frente al sensor).

Errores típicos — P1


Problema 2 — CPU von Neumann: microoperaciones y unidad de control (4 puntos)

Figura del enunciado (imagen nativa del PDF, idéntica a la del P3 de junio-2024): la Unidad de Procesado de Datos von Neumann con el bus interior y los pares ENx/Cx.
Figura del enunciado (imagen nativa del PDF, idéntica a la del P3 de junio-2024): la Unidad de Procesado de Datos von Neumann con el bus interior y los pares ENx/Cx.

Planteamiento. La Unidad de Procesado transfiere datos por un bus interior de 8 bits: la línea ENx de un registro lo conecta al bus (alta impedancia si no está habilitada) y la línea Cx lo carga desde el bus (números exactos de la figura: RT=EN2/C2, MARL=EN3/C3, MARH=EN4/C4, PCH=EN5/C5, PCL=EN6/C6, IR=EN7/C7, AC=EN8/C8, MDR=EN9 con modo C10C9, SUBH=EN11/C12, SUBL=EN10/C11). El ciclo de carga y decodificación es idéntico para todas las instrucciones (PC→MAR, lectura de memoria→MDR, MDR→IR) y ocupa los 4 primeros micro-pasos; la ejecución varía: las instrucciones de 2 bytes leen el dato en el paso siguiente y las de dirección de 16 bits la montan byte a byte (primero la parte ALTA, luego la BAJA, como fija el enunciado) usando RT como puente. La figura nativa (jpeg incrustado en la pág. 2 del PDF) es idéntica, píxel a píxel, a la del examen de junio-2024 (mismo jpeg 1043×1073), y muestra tres cableados que condonan el plan: R de la ALU es una salida directa de RT (no hay registro R cargable), la salida de la ALU solo escribe AC (no hay camino ALU→bus) y MDR está visible con su modo C10C9 hacia el bus externo DB (D7–D0). Por eso MUL3 (×3) se hace con RT←AC y dos sumas encadenadas con RT fijo en R, y ADD fija el dato en RT. El microprograma completo son 55 microinstrucciones → MPC de 6 bits, palabra de control de 24 bits.

📚 Teoría: Tema 5, págs. 4–6 del PDF — la microinstrucción se divide en campo de selección de condiciones, campo de direcciones de salto y campo de señales de control; y los componentes MPC, multiplexor de condiciones y memoria de control (ROM).

Baremo del enunciado: microoperaciones por instrucción + separación carga/decodificación vs ejecución: 3,25 p · diseño de la UC multiplexor–memoria–contador y conexión a la UO: 0,75 p.

Líneas de control dadas + supuestos (decláralos en el examen)

C1 C0 ALU C14 C13 PC C10 C9 MDR
00 L+R 01 incrementa PCH+PCL 01 carga del bus externo y entrada hacia el interior
01 L−R 10 resetea PCH+PCL 10 carga del bus interior y salida hacia el exterior
10 L
11 R+1

Supuestos (escríbelos): la figura no rotula cargas para L ni C: L es transparente (toma el valor del bus en el ciclo de operación ALU) y la salida de la ALU se captura en AC al activarse el código C1C0 (00/01/11); con C1C0=10 inactivo, AC se carga del bus con su C8. Existe un flag Z (caja Z en la figura) que vale 1 cuando el resultado de la última operación ALU es 0 (condición de JUMP Z). Escribir en la memoria externa requiere MDR configurado como salida (C10C9=10) más un pulso de escritura WE̅ de la CPU (el dibujo no lo rotula; decláralo). La pareja C11/C12·EN10/EN11 del par SUBH/SUBL se declara SUBH=C12/EN11, SUBL=C11/EN10. El bus interior admite una sola fuente ENx por micro-paso; la lectura/escritura externa (DB↔MDR) y el incremento del PC no usan el bus interior y sí pueden ir en paralelo con una transferencia interna. La dirección de 16 bits llega en dos bytes consecutivos: primero la ALTA, luego la BAJA (lo fija el enunciado).

P2 jul24: unidad de procesado von Neumann (bus interior 8 bits) bus interior 8 bits PCH[8] EN5·C5 PCL[8] EN6·C6 IR[8] EN7·C7 SUBH[8] EN11·C12 SUBL[8] EN10·C11 C14C13: 01 suma PC, 10 reset CONTROL UC (2.º apartado) opcode IR C0–C14 EN2–EN11 WE̅ MARH[8] EN4·C4 MARL[8] EN3·C3 AB[16] A15–A0 (a Memoria) RT[8] EN2·C2 ALU L ← bus (transparente) R = salida directa de RT C1C0 Z ALU→AC (no pasa por bus) AC[8] EN8·C8 MDR[8] EN9 (salida) · C10C9 (modo) DB[8] D7–D0 (a/de Memoria) todo dato que entra o sale del procesador pasa por MDR MEM ext. (WE̅) Cx: carga desde el bus interior · ENx: salida tri-state al bus C10C9 MDR: 01 lectura externa→MDR · 10 bus interior→MDR→memoria C1C0 ALU: 00 L+R · 01 L−R · 10 L · 11 R+1 (captura en AC)

Ciclo de carga y decodificación — común a TODAS las instrucciones (T0–T3)

Paso Micro-operación Señales de control
T0 MARH ← PCH EN5, C4
T1 MARL ← PCL EN6, C3
T2 MDR ← M[MAR] y en paralelo PC ← PC+1 C10C9=01; C14C13=01
T3 IR ← MDR (decodificación; el opcode va además a CONTROL) EN9, C7; MPC ← vector(IR)

Tras T2 el PC apunta ya al byte siguiente. Contabilidad de incrementos: instrucción de 1 byte → PC suma 1 (T2); de 2 bytes → 2 (T2+E2); de 3 bytes → 3 (T2, E2 y E5). Todo lo que sigue de cada instrucción es ciclo de ejecución — y esa separación es exactamente lo que pide el enunciado (3,25 puntos).

Secuencias de ejecución por instrucción (EJECUCIÓN)

(1) LDAC $dir (00001000) — 3 bytes. AC ← M[$dir]. Ejecución (10 micro-op.):

Paso Micro-operación Control
E0 MARH ← PCH (PC apunta a la parte alta de $dir) EN5, C4
E1 MARL ← PCL EN6, C3
E2 MDR ← M[MAR] (byte ALTO de $dir); PC ← PC+1 C10C9=01; C14C13=01
E3 RT ← MDR (guardo la parte alta) EN9, C2
E4 MARL ← PCL (posición del byte BAJA; MARH sigue valiendo) EN6, C3
E5 MDR ← M[MAR] (byte BAJA); PC ← PC+1 (ya apunta a la sig. instr.) C10C9=01; C14C13=01
E6 MARH ← RT EN2, C4
E7 MARL ← MDR → MAR = $dir completo EN9, C3
E8 MDR ← M[MAR] (leo el dato; NO suma PC: los 3 incrementos van en T2, E2, E5) C10C9=01
E9 AC ← MDR EN9, C8

(2) ADD (dato) (00001001) — 2 bytes. AC ← AC + dato (actualiza Z). Ejecución (5): E0 MARH←PCH (EN5,C4) · E1 MARL←PCL (EN6,C3) · E2 MDR←M[MAR] con el dato, PC+1 · E3 RT ← MDR (EN9,C2: RT fija la entrada R directamente) · E4 AC ← L+R con C1C0=00 y EN8 en el bus (L = valor actual de AC; R = RT = dato); Z ← (resultado=0).

(3) MUL3 (00001010) — 1 byte. AC ← 3×AC (actualiza Z). La ALU no multiplica: ×3 = (AC+AC)+AC. RT guarda un operando fijo en R y L toma el valor del bus en cada suma. Ejecución (3): E0 RT ← AC (EN8,C2) · E1 AC ← L+R (C1C0=00; EN8 da L=A, R=RT=A) → AC = 2A · E2 AC ← L+R (C1C0=00; EN8 da L=2A, R=RT=A) → AC = 3A; Z←(=0). ⚠ Con esta figura no existe RT ← salida ALU (la ALU solo escribe AC) ni registro R cargable: el borrador clásico «L←AC, R←AC, RT←C, R←RT» es imposible. Una sola suma con L=R=AC daría 2×AC, no 3×AC. C1C0=11 (R+1) no sirve para multiplicar. PC ya está completo tras T2 (1 byte).

(4) SUBR $dir (00001011) — 3 bytes. SUB ← PC (retorno); PC ← $dir. Ejecución (10): E0–E2 como LDAC (MAR←PC, lee byte ALTO, PC+1) · E3 RT←MDR · E4 MARL←PCL · E5 MDR←M[MAR] (byte BAJA); PC←PC+1 → PC = instrucción siguiente (retorno) · E6 SUBH←PCH (EN5,C12) · E7 SUBL←PCL (EN6,C11) → SUB = dirección de retorno · E8 PCH←RT (EN2,C5) · E9 PCL←MDR (EN9,C6) → PC = $dir.

(5) RETS (00001100) — 1 byte. PC ← SUB. Ejecución (2): E0 PCH←SUBH (EN11,C5) · E1 PCL←SUBL (EN10,C6). El +1 del fetch sobre el opcode de RETS queda destruido por la carga: correcto.

(6) JUMP Z $dir (00001101) — 3 bytes. Salta a $dir si la última operación ALU dio 0. No se toca la ALU en la ejecución para no destruir Z. Ejecución (10): E0–E5 idénticos al montaje LDAC (RT=alta, MDR=baja, PC+1 en E2 y E5 → PC = opcode+3, efecto «no salto») · E6 decisión sobre Z (micro-paso sin señales; en la UC: MPC ← A+Z): Z=0 → paso nulo E7' → fetch siguiente; Z=1 → E7 PCH←RT (EN2,C5) · E8 PCL←MDR (EN9,C6) → PC = $dir.

(7) STAC $dir (00001110) — 3 bytes. M[$dir] ← AC. Ejecución (10): E0–E7 como LDAC hasta MAR = $dir · E8 MDR ← AC con C10C9=10 y EN8 (bus interior → MDR, configurado como salida al exterior) · E9 M[MAR]←MDR (pulso WE̅ a la memoria).

(8) STOP (00001111) — 1 byte. Tras el fetch (T0–T3) el microprograma entra en un bucle sin señales (MPC auto-saltándose): unidad operativa inactiva hasta reset. No genera ningún incremento (el +1 de T2 del fetch es común a todo fetch y queda inutilizado).

Verificación: estas 8 secuencias se codificaron como el microprograma de la tabla del apartado de la UC (micro 00H–36H) y se ejecutaron en un modelo Python de la unidad de procesado (con la regla de un solo driver ENx por ciclo, MAR completo antes de cada acceso a memoria e IR cargado siempre desde MDR) con el programa LDAC $2000 (dato 07H) · ADD 5 · MUL3 · SUBR $3000 (ADD 1; RETS) · STAC $0040 · JUMP Z $5000 · STOP: AC = 07H → 0CH → 24H → (subr) 25H, SUB = 0009H, tras RETS PC = 0009H, M[0040H] = 25H, JUMP Z no tomado (el último ALU, ADD 1, dejó Z=0), PC final 0010H. Segundo test con ADD FB (AC=05+FB=00 → Z=1) y subrutina vacía: MUL3(0)=0 mantiene Z=1 y JUMP Z tomado → PC = 5000H y STOP en 5000H deja PC final 5001H. Todos los PC intermedios exactos.

Unidad de control: multiplexor – memoria de control – contador, y conexión a la UO (0,75 p)

📚 Teoría: Tema 5, pág. 9 del PDF — «Diseño de la unidad de control (I)»: el tamaño de la memoria de control lo condiciona el tamaño del microprograma y la palabra debe contener el campo de selección de condiciones, el de direcciones de salto y el de señales de control.

Componentes y conexión (dibujar):

              ┌────────────────────────────────────────────────────┐
              │  MUX 5:1 de siguiente dirección (campo SEL)        │
              │   000: MPC+1        011: vector(IR) ← mini-ROM     │
              │   001: A+Z (salto   010: A (salto abs./STOP)       │
              │         condicional) 100: 000000 (fin: fetch)      │
              └───────────────┬────────────────────────────────────┘
                              ▼ carga paralela / cuenta
  reset ──► MPC (contador 6 bits) ──► MC (ROM/PLA 64 palabras × 24 bits) ──► CMBR
  CMBR: campos SRC/DEST ──► descodificador SRC→ENx; descodificador DEST→Cx;
        C1C0→ALU; C10C9→MDR; C14C13→PC; WE→pulso WE̅ a la memoria externa
  CMBR: SEL y A ──► MUX anterior;  IR(3:0) ──► mini-ROM vector (opcode→dirección);
  Z (flag ALU) ──► suma A+Z;  reset ──► MPC←0

P2 jul24: unidad de control multiplexor–memoria–contador mini-ROM vector (16×6, dir = IR(3:0)) Z (flag de la ALU) MUX 5:1 (campo SEL) 000: MPC+1 · 001: A+Z 010: A · 011: vector(IR) 100: 000000 (fin→fetch) MPC contador (6 bits) cuenta / carga reset→0 MC memoria de control (64×24) dir CMBR (24 bits) SEL, A descodificador SRC → ENx descodificador DEST → Cx C1C0 · C10C9 C14C13 · WE (directas) campos de la microorden UNIDAD OPERATIVA (figura de la derecha): ENx habilitan registros al bus · Cx cargan · ALU, MDR, PC WE̅ a memoria externa · Z del ALU y IR(3:0) entran a la UC

Mapa del microprograma (55 microinstrucciones, direcciones MC):

Instrucción opcode Dirección MC Micro-op. ejecución
Fetch (T0–T3) — 00H–03H — (común)
LDAC 08H 04H–0DH 10
ADD 09H 0EH–12H 5
MUL3 0AH 13H–15H 3
SUBR 0BH 16H–1FH 10
RETS 0CH 20H–21H 2
JUMP Z 0DH 22H–2BH 8 + decisión + paso nulo
STAC 0EH 2CH–35H 10
STOP 0FH 36H (bucle SEL=010, A=36H) 0

Vector código→dirección (mini-ROM 16×6 indexada por IR(3:0), usada en SEL=011 de la micro 03H): 08H→04H, 09H→0EH, 0AH→13H, 0BH→16H, 0CH→20H, 0DH→22H, 0EH→2CH, 0FH→36H (códigos 00H–07H no definidos: pueden dirigir a 36H como si fueran STOP).

Tabla completa de microinstrucciones (cada fila es un ciclo del modelo ejecutado; -- = campo inactivo; la columna EN es la fuente al bus interior y la columna C la carga desde el bus):

MC EN (origen) C (destino) C1C0 C10C9 C14C13 WE SEL A Acción
00H EN5 PCH C4 MARH -- -- -- 0 000 -- MARH←PCH
01H EN6 PCL C3 MARL -- -- -- 0 000 -- MARL←PCL
02H -- -- -- 01 01 0 000 -- MDR←M[MAR]; PC+1
03H EN9 MDR C7 IR -- -- -- 0 011 -- IR←MDR; MPC←vector(IR)
04H EN5 PCH C4 MARH -- -- -- 0 000 -- LDAC: MARH←PCH
05H EN6 PCL C3 MARL -- -- -- 0 000 -- MARL←PCL
06H -- -- -- 01 01 0 000 -- lee byte alto $dir; PC+1
07H EN9 MDR C2 RT -- -- -- 0 000 -- RT←alta($dir)
08H EN6 PCL C3 MARL -- -- -- 0 000 -- MARL←PCL
09H -- -- -- 01 01 0 000 -- lee byte bajo; PC+1
0AH EN2 RT C4 MARH -- -- -- 0 000 -- MARH←alta
0BH EN9 MDR C3 MARL -- -- -- 0 000 -- MARL←bajo → MAR=$dir
0CH -- -- -- 01 -- 0 000 -- MDR←M[$dir] (sin PC+1)
0DH EN9 MDR C8 AC -- -- -- 0 100 -- AC←MDR; fetch siguiente
0EH EN5 PCH C4 MARH -- -- -- 0 000 -- ADD: MARH←PCH
0FH EN6 PCL C3 MARL -- -- -- 0 000 -- MARL←PCL
10H -- -- -- 01 01 0 000 -- MDR←dato; PC+1
11H EN9 MDR C2 RT -- -- -- 0 000 -- RT←dato (R=RT directo)
12H EN8 AC -- 00 -- -- 0 100 -- AC←L+R; Z; fetch
13H EN8 AC C2 RT -- -- -- 0 000 -- MUL3: RT←AC
14H EN8 AC -- 00 -- -- 0 000 -- AC←AC+RT=2AC (R=RT fijo)
15H EN8 AC -- 00 -- -- 0 100 -- AC←AC+RT=3AC; Z; fetch
16H EN5 PCH C4 MARH -- -- -- 0 000 -- SUBR: MARH←PCH
17H EN6 PCL C3 MARL -- -- -- 0 000 -- MARL←PCL
18H -- -- -- 01 01 0 000 -- lee byte alto; PC+1
19H EN9 MDR C2 RT -- -- -- 0 000 -- RT←alta($dir)
1AH EN6 PCL C3 MARL -- -- -- 0 000 -- MARL←PCL
1BH -- -- -- 01 01 0 000 -- lee byte bajo; PC+1 (=retorno)
1CH EN5 PCH C12 SUBH -- -- -- 0 000 -- SUBH←PCH
1DH EN6 PCL C11 SUBL -- -- -- 0 000 -- SUBL←PCL → SUB=retorno
1EH EN2 RT C5 PCH -- -- -- 0 000 -- PCH←alta($dir)
1FH EN9 MDR C6 PCL -- -- -- 0 100 -- PCL←bajo → PC=$dir; fetch
20H EN11 SUBH C5 PCH -- -- -- 0 000 -- RETS: PCH←SUBH
21H EN10 SUBL C6 PCL -- -- -- 0 100 -- PCL←SUBL; fetch
22H EN5 PCH C4 MARH -- -- -- 0 000 -- JZ: MARH←PCH
23H EN6 PCL C3 MARL -- -- -- 0 000 -- MARL←PCL
24H -- -- -- 01 01 0 000 -- lee byte alto; PC+1
25H EN9 MDR C2 RT -- -- -- 0 000 -- RT←alta($dir)
26H EN6 PCL C3 MARL -- -- -- 0 000 -- MARL←PCL
27H -- -- -- 01 01 0 000 -- lee byte bajo; PC+1 (no salta)
28H -- -- -- -- -- 0 001 29H MPC←29H+Z: Z=0→29H · Z=1→2AH
29H -- -- -- -- -- 0 100 -- Z=0: paso nulo → fetch siguiente
2AH EN2 RT C5 PCH -- -- -- 0 000 -- Z=1: PCH←alta($dir)
2BH EN9 MDR C6 PCL -- -- -- 0 100 -- PCL←bajo → PC=$dir; fetch
2CH EN5 PCH C4 MARH -- -- -- 0 000 -- STAC: MARH←PCH
2DH EN6 PCL C3 MARL -- -- -- 0 000 -- MARL←PCL
2EH -- -- -- 01 01 0 000 -- lee byte alto; PC+1
2FH EN9 MDR C2 RT -- -- -- 0 000 -- RT←alta($dir)
30H EN6 PCL C3 MARL -- -- -- 0 000 -- MARL←PCL
31H -- -- -- 01 01 0 000 -- lee byte bajo; PC+1
32H EN2 RT C4 MARH -- -- -- 0 000 -- MARH←alta
33H EN9 MDR C3 MARL -- -- -- 0 000 -- MARL←bajo → MAR=$dir
34H EN8 AC -- -- 10 -- 0 000 -- MDR←AC (bus interior, salida exterior)
35H -- -- -- -- -- 1 100 -- M[MAR]←MDR (WE̅); fetch
36H -- -- -- -- -- 0 010 36H STOP: bucle sin señales

Justificación de anchuras: 55 microinstrucciones ≤ 64 → MPC y campo A de 6 bits; palabra de control (CMBR) de 24 bits en el orden SRC(4) DEST(4) C1C0(2) C10C9(2) C14C13(2) WE(1) SEL(3) A(6) = 4+4+2+2+2+1+3+6 = 24. Codificación de los campos:

Campo Bits Codificación
SRC 4 0000=bus flotante · 0001=AC (EN8) · 0010=MDR (EN9) · 0011=RT (EN2) · 0100=PCH (EN5) · 0101=PCL (EN6) · 0110=SUBH (EN11) · 0111=SUBL (EN10)
DEST 4 0000=ninguna · 0001=AC (C8) · 0010=IR (C7) · 0011=RT (C2) · 0100=PCH (C5) · 0101=PCL (C6) · 0110=MARH (C4) · 0111=MARL (C3) · 1000=SUBH (C12) · 1001=SUBL (C11)
C1C0 2 operación ALU; en filas que no la usan se pone 10 (= pasa L), inocuo porque la captura ALU→AC solo ocurre con códigos de operación (00/01/11)
C10C9 2 00 inactivo · 01 lectura externa→MDR · 10 bus interior→MDR hacia memoria
C14C13 2 00 nada · 01 incrementa PC · 10 reset PC
WE 1 pulso de escritura WE̅ a memoria externa
SEL 3 000 MPC+1 · 001 MPC←A+Z · 010 MPC←A · 011 MPC←vector(IR) · 100 MPC←000000 (fetch)
A 6 dirección de salto (0 si SEL=000/011/100)

El problema no pide codificación binaria de palabras de control: con la tabla de campos y el mapa anterior queda diseñado el formato. (📚 Tema 5, págs. 17–18: el microprograma simbólico del procesador de ejemplo arranca con el mismo fetch que aquí — MAR←PC, IR←M(MAR), PC←PC+1 — y las microórdenes del mapa anterior son directamente codificables en ese formato.)

Errores típicos — P2


Problema 3 — Mapa de memoria de 64K posiciones (2 puntos)

Enunciado íntegro del Problema 3 (mapa de memoria para la CPU del problema anterior): tamaños de cada bloque, anclajes (RAM1 acaba al final, RAM2 empieza en el centro, ES2 arranca en «C000»), polaridades CE/WE y la única CI permitida: 4K×4. El baremo real es 0,5 + 1 + 0,5 = 2 puntos.
Enunciado íntegro del Problema 3 (mapa de memoria para la CPU del problema anterior): tamaños de cada bloque, anclajes (RAM1 acaba al final, RAM2 empieza en el centro, ES2 arranca en «C000»), polaridades CE/WE y la única CI permitida: 4K×4. El baremo real es 0,5 + 1 + 0,5 = 2 puntos.

Planteamiento. La CPU del problema 2 tiene bus de datos de 8 bits y direcciones de 16 bits → 64K posiciones (2¹⁶ = 10000H), mapa 0000H–FFFFH, líneas A15–A0. Se colocan EPROM de 16K al principio, ES1 de 2K a continuación, RAM2 de 8K en el centro (8000H), ES2 de 2K en C000H y RAM1 de 1K anclada al final; no hay solapes. Con CIs de 4K×4 hay expansión de palabras y de bits en la EPROM y en RAM2, y la decodificación se hace con las 6 líneas altas A15–A10 respetando la polaridad CE/WE de cada bloque (EPROM, RAM1 y ES1 con CE ALTO; ES2 y RAM2 con CE BAJO).

Datos que fija el enunciado y decisiones de diseño. Fija el enunciado: que el mapa sea "para la CPU del ejercicio anterior" —el problema 2 fija bus de direcciones A15–A0 y bus de datos D7–D0→ 64K posiciones de 8 bits; los cinco módulos con su tamaño y su anclaje: EPROM 16K desde el comienzo del mapa, ES1 2K justo después de la EPROM, RAM2 8K a partir del centro del mapa, ES2 2K a partir de la dirección C000 y RAM1 1K que acaba justo al final; las polaridades de control (EPROM: CE ALTO, el enunciado no le menciona WE porque es ROM; ES1 y RAM1: CE ALTO y WE BAJO; ES2 y RAM2: CE BAJO y WE BAJO); que "pueden usarse" CIs de memoria de 4K posiciones de 4 bits cada una; y el baremo: a) esquema general + tabla del mapa + cálculos: 0,5 p · b) diagrama lógico con decodificador y puertas: 1 p · c) módulo VHDL del decodificador: 0,5 p. El examen escribe la dirección de inicio de ES2 como "C000" sin sufijo H: en esta guía se usa la notación C000H, como en el resto del mapa. No lo fija el enunciado: el decodificador concreto (solo pide "un decodificador y las puertas necesarias"). La guía usa un decodificador 3–8 habilitado con entradas A15,A14,A13 y salidas Y0–Y7 activas ALTO, más puertas AND/OR: es decisión propia igualmente válida que usar solo puertas con las 6 líneas altas A15–A10 (se desarrollan las dos versiones en el apartado b) o un circuito programable como el VHDL del apartado c). El examen enumera los módulos en orden EPROM, RAM1, ES1, ES2, RAM2; la guía los ordena por posición en el mapa (EPROM, ES1, RAM2, ES2, RAM1), que es como se usan en los cálculos.

Datos de partida y cálculos de cabida

📚 Teoría: Tema 5, pág. 32 del PDF «Tema 5 SD-II_20230215.pdf» — capacidad direccionable y concepto de mapa. 📚 Teoría: Tema 1, pág. 53 del PDF «Tema 1 SD-II_20200206.pdf» — memoria organizada en palabras de m bits.

a) Esquema general, tabla del mapa y cálculos (0,5 p)

Módulo Tamaño Inicial Final CE WE Direcciones internas
EPROM 16K 0000H 3FFFH ALTO — (ROM) A13–A0
ES1 2K 4000H 47FFH ALTO BAJO A10–A0
Hueco 14K 4800H 7FFFH — — —
RAM2 8K 8000H 9FFFH BAJO BAJO A12–A0
Hueco 8K A000H BFFFH — — —
ES2 2K C000H C7FFH BAJO BAJO A10–A0
Hueco 13K C800H FBFFH — — —
RAM1 1K FC00H FFFFH ALTO BAJO A9–A0

Nº de CIs por bloque (el enunciado permite bloques de 4K posiciones × 4 bits):

Bloque CI disponible Palabras Bits Nº CI
EPROM 16K×8 4K×4 16K/4K = 4 filas 8/4 = 2 en paralelo 8
RAM2 8K×8 4K×4 8K/4K = 2 filas 8/4 = 2 en paralelo 4
RAM1 1K×8 4K×4 (solo hace falta 1K) 1 fila 8/4 = 2 en paralelo 2 (los CI de 4K solo se decodifican para 1K: A11–A10 de la CI fijados a 0; el rango seleccionado es FC00H–FFFFH exactamente)
ES1, ES2 módulos E/S hechos (2K×8) — — 1 + 1

Total: 14 CIs de memoria (8+4+2) más 2 módulos E/S. En cada fila, un CI lleva los bits D3–D0 y su gemelo en paralelo D7–D4 (comparten direcciones y CE; la otra mitad de los 4 bits queda cubierta).

Esquema general del mapa (el apartado a) pide esquema + tabla; la tabla va arriba y el esquema, debajo):

Mapa de memoria 64K posiciones × 8 bits (A15–A0 · D7–D0) — 0000H–FFFFH inicio posiciones 0000H EPROM 16K×8 · CE ALTO (sin WE) 0000H–3FFFH · 4 filas × 2 CI 4K×4 en paralelo (8 CI) desde el comienzo del mapa 16.384 4000H ES1 2K×8 · CE ALTO · WE BAJO 4000H–47FFH · módulo E/S hecho (2K×8) justo después de la EPROM 2.048 4800H Hueco 14K · 4800H–7FFFH (sin decodificar) aquí no se activa ninguna CE/CS 14.336 8000H RAM2 8K×8 · CE BAJO · WE BAJO 8000H–9FFFH · 2 filas × 2 CI 4K×4 en paralelo (4 CI) a partir del centro (10000H/2 = 8000H) 8.192 A000H Hueco 8K · A000H–BFFFH (sin decodificar) 8.192 C000H ES2 2K×8 · CE BAJO · WE BAJO C000H–C7FFH · módulo E/S hecho (2K×8) a partir de la dirección C000 del enunciado 2.048 C800H Hueco 13K · C800H–FBFFH (sin decodificar) 13.312 FC00H RAM1 1K×8 · CE ALTO · WE BAJO FC00H–FFFFH · 2 CI 4K×4 en paralelo (sobredimensionada) acaba justo al final del mapa (FFFFH) 1.024 FFFFH Bloques del enunciado en orden de mapa; direcciones calculadas en el apartado a) Alturas de caja NO a escala: lo que fija el mapa son las direcciones de la izquierda y los tamaños de la derecha. Suma de bloques: 16K+2K+8K+2K+1K = 29K = 29.696 ≤ 65.536 ✔ · huecos = 35.840 · sin solapes (comprobado dirección a dirección). Cada fila de CI en paralelo: una CI conduce D3–D0 y su gemela D7–D4 (comparten direcciones y señal de habilitación).

Figura: esquema del mapa de 64K posiciones en orden, con tamaños, rangos y polaridades CE/WE.

📚 Teoría: Tema 5, pág. 33 del PDF «Tema 5 SD-II_20230215.pdf» — ejemplo de mapa: ROM al final, RAM al principio. 📚 Teoría: Tema 1, pág. 54 del PDF «Tema 1 SD-II_20200206.pdf» — tipos de ROM: programables, PROM y EPROM.

b) Decodificación y diagrama lógico (1 p)

El bloque más pequeño mide 1K → hay que decodificar con las 6 líneas altas A15–A10. Estructura práctica: un decodificador 3–8 habilitado conectado a A15,A14,A13 (salidas Y0–Y7 activas ALTO, cada una = un sector de 8K) más puertas:

Y Sector Uso
Y0, Y1 0000H–3FFFH EPROM: CE(EPROM) = Y0 + Y1 (16K justas; cada una habilita 2 de las 4 filas según A13 — ver ecuaciones de abajo)
Y2 4000H–5FFFH ES1 (1ª mitad): CE(ES1) = Y2 · A̅12 · A̅11
Y4 8000H–9FFFH RAM2 exacto: CE̅(RAM2) = Y̅4 (sector de 8K justas)
Y6 C000H–DFFFH ES2 (1ª mitad): CE̅(ES2) = Y̅6 + A12 + A11 (OR: activo BAJO)
Y7 E000H–FFFFH RAM1 (última 1K): CE(RAM1) = Y7 · A12 · A11 · A10

(En un Y con salida ALTO, una señal activa BAJO se consigue negando el producto: CE̅(ES2) = NOT(Y6·A̅12·A̅11) = Y̅6 + A12 + A11.)

Ecuaciones equivalentes directamente en las 6 líneas altas (válidas y más compactas si no se dibuja el 3–8):

Diagrama lógico (descripción para dibujar): CPU con A15–A0, D7–D0 y WE̅. La EPROM: 8 CI 4K×4 en 4 filas de 2 (gemelos comparten CE y direcciones); A11–A0 a todas; CE de cada fila con la ecuación CE_E0..E3. ES1: módulo 2K×8, A10–A0, CE = ecuación, WE̅ de la CPU. RAM2: 4 CI 4K×4 en 2 filas de 2, A11–A0, CS̅ = ecuaciones CS_R0̅/CS_R1̅, WE̅ común. ES2: módulo 2K×8, A10–A0, CE̅ y WE̅. RAM1: 2 CI en paralelo, A9–A0, CE = ecuación (ALTO), WE̅. WE̅ de la CPU va a RAM1, RAM2, ES1 y ES2 (la EPROM no lleva WE). Las ecuaciones se montan con el decodificador 3–8 (A15,A14,A13 a las entradas de selección; entrada de habilitación fija activa) más las puertas AND/OR indicadas.

El diagrama lógico montado (es la descripción anterior dibujada: decodificador 3–8, puertas para cada CS y los CIs 4K×4 en paralelo por filas):

DECODIFICADOR 3–8 habilitado + puertas Entradas A15,A14,A13 · salidas Y0–Y7 (ALTO, 8K c/u) Y0..Y3: sectores 0000H–7FFFH Y4..Y7: sectores 8000H–FFFFH Cada CS usa una puerta AND/NAND (columna central) EP: CE_E0..E3 ALTO · ES1: CE ALTO · RAM1: CE ALTO RAM2: CS BAJO · ES2: CS BAJO · huecos: nada activo A15–A13 van al 3–8; A12,A11,A10 van a las puertas CPU (la del problema 2) Buses: direcciones A15–A0 · datos D7–D0 · WE‾ (BAJO) WE‾ va a RAM1, RAM2, ES1 y ES2 (EPROM no usa WE) En cada par en paralelo: una CI lleva D3–D0 y otra D7–D4 Direcciones internas de cada bloque: ver pie del dibujo RAM1 1K×8 · FC00H–FFFFH · CE ALTO · WE BAJO R1a · 4K×4 · CE (ALTO) D3–D0 · A9–A0 R1b · 4K×4 · CE (ALTO) D7–D4 · A9–A0 CI 4K×4 sobredimensionada: A11,A10 de la CI fijadas a 0 EPROM 16K×8 · 0000H–3FFFH · CE ALTO (por fila) E0a · 4K×4 · CE_E0 D3–D0 · A11–A0 E0b · 4K×4 · CE_E0 D7–D4 · A11–A0 E1a · 4K×4 · CE_E1 D3–D0 · A11–A0 E1b · 4K×4 · CE_E1 D7–D4 · A11–A0 E2a · 4K×4 · CE_E2 D3–D0 · A11–A0 E2b · 4K×4 · CE_E2 D7–D4 · A11–A0 E3a · 4K×4 · CE_E3 D3–D0 · A11–A0 E3b · 4K×4 · CE_E3 D7–D4 · A11–A0 ES1 2K×8 · 4000H–47FFH CE (ALTO): puerta izq. A10–A0 y D7–D0: dcha. RAM2 8K×8 · 8000H–9FFFH · CS BAJO (por fila) R0a · 4K×4 · CS_R0 D3–D0 · A11–A0 R0b · 4K×4 · CS_R0 D7–D4 · A11–A0 R1a · 4K×4 · CS_R1 D3–D0 · A11–A0 R1b · 4K×4 · CS_R1 D7–D4 · A11–A0 ES2 2K×8 · C000H–C7FFH CE (BAJO): puerta izq. WE‾ y A,D: por abajo Y0–Y7 + A12,A11,A10 Y0 · A12=0 Y0 · A12=1 Y1 · A12=0 Y1 · A12=1 Y2·A12=0·A11=0 Y4·A12=0 Y4·A12=1 Y6·A12=0·A11=0 Y7 · A12=1 · A11=1 · A10=1 A15–A13 al decodificador A15–A0 del CPU D7–D0 WE‾ WE‾ Direcciones internas: CI de EPROM y RAM2 = A11–A0 · ES1 y ES2 = A10–A0 · CI de RAM1 = A9–A0 (A11,A10 de la CI a 0). ES1 y ES2 reciben también D7–D0 y WE‾ de la CPU. Etiqueta bajo cada puerta = entradas de la AND/NAND (burbuja = BAJO).

Figura: diagrama lógico del mapa — decodificador 3–8 + puertas AND/NAND, EPROM (4 filas × 2 CI), RAM2 (2 filas × 2 CI), RAM1 (2 CI sobredimensionadas) y los módulos ES1/ES2, con buses A15–A0, D7–D0 y WE̅.

📚 Teoría: Tema 5, pág. 34–35 del PDF «Tema 5 SD-II_20230215.pdf» — condiciones de habilitación según líneas altas. 📚 Teoría: Tema 1, pág. 3–5 del PDF «Tema 1 SD-II_20200206.pdf» — decodificador completo: n entradas y 2ⁿ salidas. 📚 Teoría: Tema 5, pág. 40 del PDF «Tema 5 SD-II_20230215.pdf» — opciones de decodificación: decodificador, puertas o VHDL.

c) Módulo VHDL del decodificador (0,5 p)

Analizado con GHDL y simulado con un banco de 64 muestras representativas (una por cada bloque de 1024 direcciones — como el módulo solo recibe A15–A10, esas 64 muestras agotan su espacio de entrada), y comprobado además barriendo las 65.536 direcciones del mapa con las ecuaciones equivalentes del apartado b): cada señal activa exactamente en su rango, cero solapes, huecos sin activar (0 fallos). El bloque es decodificación directa por compuertas — estilo del enunciado, intacto en el pase de estilo — y el barrido se ha vuelto a ejecutar contra él en GHDL --std=08 -fsynopsys (12/11): mismas cuentas exactas y 0 solapes.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity Decodificador_Map is
    port (
        A       : in  std_logic_vector(15 downto 10);  -- 6 lineas altas
        CE_EP   : out std_logic_vector(3 downto 0);    -- 4 filas EPROM 4Kx8, CE ALTO
        CE_ES1  : out std_logic;                       -- ES1 4000H-47FFH, CE ALTO
        CS_RAM2 : out std_logic_vector(1 downto 0);    -- 2 filas RAM2 4Kx8, CS BAJO
        CS_ES2  : out std_logic;                       -- ES2 C000H-C7FFH, CS BAJO
        CE_RAM1 : out std_logic                        -- RAM1 FC00H-FFFFH, CE ALTO
    );
end entity Decodificador_Map;

architecture Behaviour of Decodificador_Map is
begin
    -- EPROM 0000H-3FFFH: filas de 4K elegidas con A13,A12 (sector A15A14=00)
    CE_EP(0) <= not A(15) and not A(14) and not A(13) and not A(12);  -- 0000H-0FFFH
    CE_EP(1) <= not A(15) and not A(14) and not A(13) and     A(12);  -- 1000H-1FFFH
    CE_EP(2) <= not A(15) and not A(14) and     A(13) and not A(12);  -- 2000H-2FFFH
    CE_EP(3) <= not A(15) and not A(14) and     A(13) and     A(12);  -- 3000H-3FFFH
    -- ES1 4000H-47FFH (2K)
    CE_ES1  <= not A(15) and     A(14) and not A(13) and not A(12) and not A(11);
    -- RAM2 8000H-9FFFH (8K): sector A15=1 A14=0 A13=0; filas por A12. Activa BAJO
    CS_RAM2(0) <= not (    A(15) and not A(14) and not A(13) and not A(12)); -- 8000H-8FFFH
    CS_RAM2(1) <= not (    A(15) and not A(14) and not A(13) and     A(12)); -- 9000H-9FFFH
    -- ES2 C000H-C7FFH (2K). Activa BAJO
    CS_ES2  <= not (    A(15) and     A(14) and not A(13) and not A(12) and not A(11));
    -- RAM1 FC00H-FFFFH (1K): A15..A10 = 1
    CE_RAM1 <=     A(15) and     A(14) and     A(13) and     A(12) and A(11) and A(10);
end architecture Behaviour;

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

Errores típicos — P3

Esquema-resumen de la metodología

  1. Derivar el espacio de la CPU del problema anterior — A15–A0 y D7–D0 del P2 fijan 64K posiciones × 8 bits y el mapa 0000H–FFFFH; decláralo, el P3 no lo repite.
  2. Pasar tamaños a hex y calcular inicio/fin de cada bloque según su anclaje — al comienzo (base 0000H), "justo después" (fin previo + 1), "centro" (10000H/2 = 8000H), dirección dada (C000H) y "acaba al final" (inicio = FFFFH − tamaño + 1 = FC00H).
  3. Comprobar cabida y huecos — suma de tamaños (29K ≤ 64K) y comprobación tamaño = final − inicio + 1 en cada fila; los huecos resultantes (4800H–7FFFH, A000H–BFFFH, C800H–FBFFH) se listan pero no se decodifican.
  4. Montar cada bloque con los CIs permitidos — expansión de palabras × bits con CIs 4K×4: 2 CI en paralelo por fila (D3–D0 y D7–D4); EPROM 8 CI, RAM2 4 CI, RAM1 2 CI sobredimensionadas con A11,A10 fijas a 0 — justifícalo en una línea.
  5. Fijar cuántas líneas se decodifican — el bloque más pequeño (1K) consume A9–A0 → decodificar con las 6 líneas altas A15–A10; con menos habría solapes.
  6. Escribir la ecuación CS de cada bloque con su polaridad — CE ALTO: producto directo de las líneas altas; CE BAJO: producto negado (NAND/burbuja); respeta WE̅ solo donde el enunciado lo da.
  7. Elegir y justificar la estructura de decodificación — 3–8 habilitado en A15,A14,A13 + puertas por CS, o ecuaciones puras con A15–A10 (las dos son válidas; el examen solo pide "un decodificador y las puertas").
  8. Dibujar el diagrama lógico completo — CPU, buses con nº de líneas, decodificador con sus entradas y salidas Yk, puertas por CS, filas de CI en paralelo y WE̅ a RAM1, RAM2, ES1 y ES2.
  9. Pasar la decodificación a VHDL — una expresión concurrente por señal sobre A15–A10, salidas vectoriales por filas; analizar con GHDL.
  10. Barrer todas las direcciones del mapa — cada dirección en 0 o 1 bloque y conteos = tamaños (16.384/2.048/8.192/2.048/1.024, resto hueco): es lo que caza polaridades invertidas y fronteras mal calculadas (FC00H vs F400H).

Idea transversal: el mapa lo fijan solo los anclajes del enunciado; el decodificador es la parte de decisión propia, y tanto uno como otro se validan barriendo las 65.536 direcciones, no probando direcciones sueltas.

Checklist final antes de entregar

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.