Guía de resolución — Examen de Sistemas Digitales II, Octubre 2023 (09-10-2023)

Guía modelo para preparar la convocatoria de nov-dic 2026. El examen tiene 2 problemas: automatización de una persiana eléctrica (diagrama ASM + VHDL + microcontrolador PicoBlaze) y mapa de memoria 1M×16 para una CPU con bus de 20 direcciones y 16 datos (mapa, tabla de direccionamiento, decodificador con 3-a-8 + puertas y módulo VHDL FPGA).

Importante (criterio del curso): el planteamiento de cada ejercicio es clave y no se puntúan los ejercicios cuyo planteamiento no sea adecuado. Escribe 2-3 frases de planteamiento antes de desarrollar, declara cada supuesto (aquí hay varios: figuras perdidas y tabla de CIs ilegible), justifica cada elección y deja el resultado final verificable (tablas, código, valores concretos).

Verificación de esta guía: ejecutada con GHDL 4.1.0 y Python 3. (1) El Problema 1 (persiana) tiene la tabla de transiciones del ASM auditada una a una contra las 9 conductas del enunciado. El VHDL de 1.b fue reescrito al estilo de clase el 12/11/2026 (proceso único wait until clk='1', reset síncrono, contador dentro del proceso con comparaciones por igualdad sobre vectores; ver guias/ESTILO-VHDL-profesor.md) y re-simulado con GHDL estricto (--std=08 -fsynopsys) tal cual está en la guía con una TB nueva que coteja los 9 comportamientos del enunciado uno a uno (entorno mecánico que activa A/C al acabar el tramo), con pausa de inversión medida EXACTA en dos escalas de generics —(PRE=9, DIV=3) → 31 flancos = (9+1)·3+1 y (PRE=49, DIV=2) → 101 = (49+1)·2+1, linealidad confirmada—, que extrapola a 20.000.000 pulsos = 2,000 s exactos a 10 MHz; el monitor de enclavamiento R·E nunca disparó y el reset a mitad de pausa corta la cuenta y deja la máquina viva. Las 3 mutaciones típicas se han re-ejecutado contra la estructura nueva y las 3 caen con simulation failed (V1 invertir sin pausa: SUBE→BAJA directo; V2 polaridad de A al revés; V3 E activado durante SUBE, violando el enclavamiento). (2) El decodificador del P2 se barrió de nuevo en GHDL en las 1.048.576 direcciones (12/11): CE correctas y recuentos exactos RAM1=262.144, RAM2=262.144, ROM1=131.072, ROM2=131.072, E/S=16.384, hueco=245.760 (suma = 1M), sin solapes. El barrido detectó además dos errores reales de ecuación en mi primer borrador (OR en lugar de AND con salidas activas a bajo, y A16 olvidada en el E/S → se activaba en EC000H): ver los apartados e/f — comprueba SIEMPRE las direcciones frontera de cada bloque. (3) El ensamblador PicoBlaze de los 3 primeros bloques se ciñe a la tabla ISA impresa en la hoja (auditada por visión: en la hoja no existen INPUT/OUTPUT/JP/BRANCH/CONSTANT) y está verificado con un mini-emulador que ejecuta el bloque asm de la guía 1.c: recorre las 9 reglas (TRAZADA OK, 67 instrucciones) y cae con las 7 mutaciones de errores típicos N1–N7.

Supuestos declarados (figuras desparecidas en la extracción — escríbelos en el examen)

  1. P1, figura: R/E = tracción (R recoge = SUBE, E extiende = BAJA); A = final de carrera de arriba; C = final de carrera de abajo; S/B/P pulsadores. Ojo con la lógica de A: A produce nivel ALTO mientras NO está arriba → arriba del todo es A=0. C produce nivel ALTO cuando está totalmente cerrada = totalmente abajo.
  2. P1, entradas: S, B, P son niveles ALTO mantenidos mientras se pulsan (no pulsos); el propio enunciado dice que nunca se accionan varios a la vez (aplícalo: no hacen falta arbitrajes entre botones). Los finales de carrera no son pulsadores: son el estado de la mecánica y se leen a nivel.
  3. P1, arranque: al dar tensión la persiana está totalmente abajo (C=1, A=1); el registro de estado arranca en el bloque ABAJO. No hay botón de reset en el enunciado.
  4. P1, cuenta de 2 s: el enunciado no da contador. Propuesta (patrón del curso): contador de 20.000.000 de pulsos hecho en la FPGA — en VHDL (apartado b) como pre-escala MOD-10⁶ × MOD-20; en PicoBlaze (apartado c) como módulo externo CTR2s arrancado por pulso de OUT y consultado por IN de FIN_CUENTA (igual que CTR5/CTR3 en junio-2024). Decláralo como tu propuesta; es la solución limpia.
  5. P1, durante la pausa de 2 s (estados ESPERA): el enunciado no dice qué pasa si se pulsan S/B/P en ese intervalo — supuesto: se ignoran (la pausa es protección del motor y termina siempre). Escríbelo.
  6. P2, tabla de CIs: recuperada por visión del escaneo original — el examen ofrece ROM {128K×1, 64K×8, 128K×8} y RAM {128K×1, 256K×8}, sin nombres comerciales. Resuelvo con la más favorable a «menor número de pastillas» (RAM 256K×8 → 4, ROM 128K×8 → 4, E/S propio → 1) y doy la fórmula general, con todas las alternativas reales calculadas en el apartado 2.b.
  7. P2, polaridades: el examen no fija señales CE/WE ni polaridades — son decisión propia del resolutor (válida y habitual en el curso): WE̅ de la CPU activa BAJA y todas las CE del mapa diseñadas activas BAJAS con el decodificador 3-a-8 de salidas activas a bajo (tipo 74138). Declara esta decisión al principio de tu respuesta.

Problema 1 — Persiana eléctrica: ASM + VHDL + PicoBlaze

Planteamiento (copia esto al principio). Es una máquina de estados con dos salidas de actuación (R=subir, E=bajar) que deben enclavarse mutuamente (nunca R=E=1), cinco entradas (S, B, P, A, C) y una cuenta de 2 s que solo aparece al invertir el sentido de marcha en movimiento (protección del motor). Diseño el ASM con estados nombrados que cubren las 9 conductas del enunciado, lo paso a VHDL con un temporizador de 2 s (20 M de pulsos a 10 MHz) y luego lo resuelvo con PicoBlaze + contador externo CTR2s.

Baremo del enunciado: a) ASM 2,5 p · b) VHDL 1,5 p · c) PicoBlaze 1,5 p. (El encabezado del problema pone "(3 puntos)" pero el baremo interno suma 5,5: son pesos internos; resuelve los tres apartados completos.)

1.0 Cálculos previos (van en el papel, puntúan)

Cuenta de 2 s con reloj de 10 MHz:

10 MHz × 2 s = 20.000.000 pulsos = 2×10⁷ = 10⁶ × 20
  → pre-escala MOD-10⁶ (cuenta 0…999.999): 20 bits (2²⁰ = 1.048.576 ≥ 10⁶)
  → contador MOD-20 (cuenta 0…19):           5 bits (2⁵ = 32 ≥ 20)
  → 10 MHz / 10⁶ = 1 tick cada 0,1 s → 20 ticks × 0,1 s = 2,0 s ✓

Total: 25 bits. Escribe la descomposición: no vale poner "MOD-2×10⁷" a secas. Alternativa igual de válida: un único contador de 25 bits (2²⁵ = 33.554.432 ≥ 20.000.000). La cascada 10⁶ × 20 es el patrón del curso: asociación síncrona de contadores en cascada usando las habilitaciones de cuenta, y aquí el tramo completo solo cuenta mientras la máquina está en un estado ESPERA (habilitación = «está en ESPERA»).

📚 Teoría: Tema 2, págs. 56–58 del PDF «Tema 2 SD-II_20200317.pdf» — contadores síncronos con habilitación y asociación síncrona en cascada (el contador de más peso solo cuenta cuando está activa su habilitación)

1.a Diagrama ASM de control (2,5 p)

7 bloques numerados en orden de aparición (esa numeración es la que pide el apartado c):

# Estado Salida Transiciones
1 ABAJO (totalmente abajo; C=1) R=0 E=0 S→2. (B y P se ignoran: ya está abajo)
2 SUBE R=1 A=0→5 (límite arriba: prioridad); P→4; B→3
3 ESPERA_2S_BAJA R=0 E=0 (parada) FIN_2S→6. Botones ignorados (supuesto 5)
4 PARADA (posición intermedia) R=0 E=0 S→2 directo; B→6 directo
5 ARRIBA (totalmente arriba; A=0) R=0 E=0 B→6 directo. (S y P se ignoran)
6 BAJA E=1 C=1→1 (límite abajo: prioridad); P→4; S→7
7 ESPERA_2S_SUBE R=0 E=0 (parada) FIN_2S→2. Botones ignorados
stateDiagram-v2 [*] --> ABAJO : arranque (C=1) ABAJO --> SUBE : S=1 SUBE --> ARRIBA : A=0 (límite, prioridad) SUBE --> PARADA : P=1 SUBE --> ESPERA_2S_BAJA : B=1 [arranca cuenta 2 s] ESPERA_2S_BAJA --> BAJA : FIN_2S=1 ARRIBA --> BAJA : B=1 BAJA --> ABAJO : C=1 (límite, prioridad) BAJA --> PARADA : P=1 BAJA --> ESPERA_2S_SUBE : S=1 [arranca cuenta 2 s] ESPERA_2S_SUBE --> SUBE : FIN_2S=1 PARADA --> SUBE : S=1 PARADA --> BAJA : B=1

Claves del planteamiento (lo que puntúa):

Ejemplo de recorrido (reglas 2→6→7): ABAJO →(S) SUBE[R=1] →(B) parada + cuenta →(2 s) BAJA[E=1] →(P) PARADA →(S, sin pausa) SUBE.

📚 Teoría: Tema 3, págs. 15–19 del PDF «Tema 3 SD-II_20200413.pdf» — elementos del diagrama ASM: caja de estado (salidas tipo Moore), caja de selección y bloque ASM (todas las operaciones de un mismo ciclo de reloj; un bloque ASM equivale a un estado del diagrama de estados) 📚 Teoría: Tema 3, págs. 23–24 del PDF «Tema 3 SD-II_20200413.pdf» — diagrama ASM y módulo VHDL equivalente

1.b Módulo VHDL (1,5 puntos)

Estructura de clase: UN proceso secuencial con wait until clk = '1' — reset síncrono, contador de 2 s dentro del proceso (habilitado solo en los dos ESPERA), case del ASM con las salidas Moore escritas en todas las ramas y when others; nombres de estado = nombres de los bloques ASM (el apartado c se referencia a ellos).

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity Persiana is
    generic (
        G_PRE_MAX : integer := 999_999;  -- pre-escala MOD-1e6 (20 bits)
        G_DIV     : integer := 20        -- MOD-20 (5 bits): 1e6 x 20 = 2x10^7 pulsos = 2 s
    );
    port (
        clk, reset    : in  std_logic;
        S, B, P, A, C : in  std_logic;   -- pulsadores y finales de carrera
        R, E          : out std_logic    -- motor: recoger (subir) / extender (bajar)
    );
end entity Persiana;

architecture ASM of Persiana is
    type mis_estados is (ABAJO, SUBE, ESPERA_2S_BAJA, ARRIBA,
                         BAJA, ESPERA_2S_SUBE, PARADA);
    signal estado : mis_estados;

    -- contador de 2 s COMPARTIDO (los dos ESPERA nunca estan activos a la vez):
    -- vectores y comparacion por IGUALDAD (999999 < 2^20; 19 < 2^5, sin desbordes)
    signal pre   : std_logic_vector(19 downto 0);        -- 0..999999
    signal tick  : std_logic_vector(4 downto 0);         -- 0..19
    signal fin2s : std_logic;
begin
    process
    begin
        wait until clk = '1';
        if reset = '1' then                    -- reset sincronico: persiana abajo
            estado <= ABAJO;   R <= '0';   E <= '0';
            pre <= (others => '0');  tick <= (others => '0');  fin2s <= '0';
        else
            ---- contador 2 s: corre solo en ESPERA, se limpia al salir ----
            if estado /= ESPERA_2S_BAJA and estado /= ESPERA_2S_SUBE then
                pre <= (others => '0');  tick <= (others => '0');  fin2s <= '0';
            elsif pre = G_PRE_MAX then          -- en el examen: if pre = 999_999
                pre <= (others => '0');
                if tick = G_DIV - 1 then fin2s <= '1';  -- examen: if tick = 19
                else                     tick <= tick + 1;
                end if;
            else
                pre <= pre + 1;
            end if;

            ---- case del ASM: salidas Moore en todas las ramas + transiciones ----
            case estado is
                when ABAJO =>
                    R <= '0';  E <= '0';
                    if S = '1' then estado <= SUBE; end if;           -- regla 1
                when SUBE =>
                    R <= '1';  E <= '0';
                    if    A = '0' then estado <= ARRIBA;              -- regla 9 (arriba)
                    elsif P = '1' then estado <= PARADA;              -- regla 3
                    elsif B = '1' then estado <= ESPERA_2S_BAJA;      -- regla 2
                    end if;
                when ESPERA_2S_BAJA =>
                    R <= '0';  E <= '0';
                    if fin2s = '1' then estado <= BAJA; end if;
                when ARRIBA =>
                    R <= '0';  E <= '0';
                    if B = '1' then estado <= BAJA; end if;           -- regla 4
                when BAJA =>
                    R <= '0';  E <= '1';
                    if    C = '1' then estado <= ABAJO;               -- regla 9 (abajo)
                    elsif P = '1' then estado <= PARADA;              -- regla 6
                    elsif S = '1' then estado <= ESPERA_2S_SUBE;      -- regla 5
                    end if;
                when ESPERA_2S_SUBE =>
                    R <= '0';  E <= '0';
                    if fin2s = '1' then estado <= SUBE; end if;
                when PARADA =>
                    R <= '0';  E <= '0';
                    if    S = '1' then estado <= SUBE;                -- regla 7 (sin pausa)
                    elsif B = '1' then estado <= BAJA;                -- regla 8 (sin pausa)
                    end if;
                when others =>
                    estado <= ABAJO;  R <= '0';  E <= '0';
            end case;
        end if;
    end process;
end architecture ASM;

Notas para el examen: escribe las constantes directamente (if pre = 999_999, if tick = 19) y pon siempre el reset síncrono aunque el enunciado no lo nombre (Tema 3, pág. 20): el estado ABAJO del reset coincide con la persiana recogida, que es el reposo natural del mecanismo. Los generic son solo para simular a escala reducida (Tema 3, págs. 33–34); en el examen van las literales 999_999 y 20 directamente.

📚 Teoría: Tema 3, págs. 30–32 del PDF «Tema 3 SD-II_20200413.pdf» — traducción del ASM a VHDL: descripción de comportamiento como máquina de estados, definiendo en cada estado las transiciones y transferencias, y añadiendo reloj y reset a la tarjeta identificativa 📚 Teoría: Tema 3, págs. 33–34 del PDF «Tema 3 SD-II_20200413.pdf» — simulación en VHDL usando parametrización: la cuenta máxima del contador se reduce en la simulación para que las escalas temporales sean manejables (el mismo truco del testbench con PRE=9)

Resultado del testbench GHDL (corrida real del 30/10/2026 con el bloque VHDL de arriba tal cual, --std=08 estricto; TB espejo de las 9 reglas + entorno mecánico que activa A/C al acabar el tramo; dos escalas de generics para confirmar linealidad):

ARRANQUE OK: abajo (C=1, A=1), motor parado
R1 OK: abajo+S -> R=1 (sube), en 1 flanco
R2 OK: subiendo+B -> parada y pausa EXACTA 31 flancos desde el flanco de entrada
       en ESPERA hasta E=1, con motor parado y posicion intacta en toda la pausa
R9b OK: C=1 durante BAJA para el motor en 1 flanco (ABAJO automatico)
R2 bis OK: 2a pausa EXACTA 31 con contador COMPARTIDO (limpio al salir de ESPERA)
R5 OK: bajando+S -> parada y pausa EXACTA 31 flancos, luego R=1
R3 OK: subiendo+P -> parada en 1 flanco (y se mantiene al soltar P)
R7 OK: parada intermedia+S sube DIRECTO en 1 flanco (sin pausa)
R8 OK: parada intermedia+B baja DIRECTO en 1 flanco (sin pausa)
R6 OK: bajando+P -> parada en 1 flanco
R9a OK: arriba del todo es A=0 y para R en 1 flanco (polaridad A correcta)
R4 OK: arriba+B baja DIRECTO en 1 flanco (sin pausa)
R6 OK (bis): bajando+P -> parada; R7 bis: parada+S sube directo en 1 flanco
R2 OK (ter): 3a inversion en movimiento, pausa EXACTA 31
R9b OK (bis): bajada completa hasta ABAJO con paro automatico
PERSIANA OK: 9 reglas verificadas | escala TPRE=9 TDIV=3 | pausa EXACTA = 31
             = (TPRE+1)*TDIV+1 | enclavamiento R/E intacto
SEGUNDA ESCALA -gTPRE=49 -gTDIV=2: pausa EXACTA = 101 = (49+1)*2+1 -> PERSIANA OK

Mutaciones (negativas del verificador; exit 1 con motivo y exit 0 al restaurar): V1 invertir el sentido sin pausa (los ESPERA saltan directo: el assert de pausa mide 1 en vez de 31) · V2 tratar A=1 como «está arriba» —la trampa del examen— (la máquina abandona SUBE enseguida y falla «debería seguir subiendo») · V3 escribir R=1 también durante BAJA, sin enclavamiento (dispara el monitor R·E simultáneas). Las tres caen en librerías de trabajo separadas con ghdl --elab-run --std=08.

Extrapolación documentada: con PRE=9, DIV=3 la pausa medida desde que el motor se para hasta que arranca al sentido contrario es (9+1)·3 + 1 = 31 flancos (30 de cuenta justa + 1 del flag fin2s). A escala real: (999.999+1)·20 + 1 = 20.000.001 flancos = 2,000 s a 10 MHz (el +1 es el registro del estado; la cuenta justa es exactamente 2×10⁷). Las transiciones "sin pausa" midieron 1 flanco, frente a los 31 con pausa — el testbench discrimina de verdad el error típico de poner la pausa en las reglas 4/7/8.

Errores típicos P1.a/b

  1. Leer A al revés (parada arriba con A=1): el enunciado dice A=1 mientras NO está arriba. Con A=1 en ARRIBA la máquina jamás para arriba. Es el error más caro del examen.
  2. R y E simultáneas (salidas asociadas al botón en vez de al estado, o elsif mal encadenado): el enclavamiento es de seguridad y se comprueba con el monitor de simulación.
  3. Pausa de 2 s donde no toca: las reglas 4, 7 y 8 son DIRECTAS (motor ya parado). Necesitas el estado PARADA separado de los ESPERA; fundirlos es el error de planteamiento.
  4. Omitir el límite dentro de SUBE/BAJA (regla 9): el paro automático vive en las transiciones A=0 y C=1 de esos dos estados, no en estados aparte.
  5. No escribir la descomposición 2×10⁷ = 10⁶×20 con los bits (20+5) — es parte del apartado a.
  6. Contador compartido sin limpiar al salir de ESPERA: la segunda pausa arrancaría con el resto de la primera. Limpieza por estado /= ESPERA_*.
  7. Proceso combinacional sin valores por defecto (latches en R/E), case incompleto, o estados llamados E0…E6 sin relación con el ASM.

1.c PicoBlaze: esquema hardware + 3 primeros bloques ASM (1,5 p)

Planteamiento. El control se implementa con el microcontrolador PicoBlaze (núcleo de 8 bits) según el diagrama impreso en la hoja (pines izquierdos IN_PORT, INTERRUPT, RESET, CLK; derechos OUT_PORT, PORT_ID, READ_STROBE, WRITE_STROBE, INTERRUPT_ACK), con el programa en una ROM externa de 1024×18 (última posición, 03FFH = vector de interrupción en RETI, sin usar; en la FPGA se hace como bloque RAM con WE fijo a 0 — Tema 4 p45). El juego de instrucciones es la tabla ISA impresa en la propia hoja (auditada abajo), que NO es la de KCPSM6: hay que ceñirse a ella. La cuenta de 2 s no la hace el software (a 10 MHz con 4 clk/instrucción, 2 s serían ~5 M de instrucciones de bucle): la hace un módulo contador externo CTR2s en la FPGA (cuenta 20.000.000 pulsos — los cálculos de 1.0 valen igual) que el programa arranca con pulsos por OUT y consulta con IN, igual que CTR5/CTR3 del curso. El bloque 4 en adelante del ASM se traduce de la misma forma; el enunciado pide solo los 3 primeros (1 ABAJO, 2 SUBE, 3 ESPERA_2S_BAJA).

Auditoría de la tabla ISA impresa en la hoja (hazla antes de ensamblar)

La tabla de la hoja está en la página 2 del PDF como imagen; recuperada con pdfimages y transcrita por zoom, el encabezado dice «Instrucción | Comentario» y agrupa así (verbatim):

«Comentario» de la hoja Instrucción
«Operaciones sin y con acarreo (finalizadas en C)» ADD sX,sY, ADD sX,kk y ADDC… · SUB/SUBC igual
«Desplazamientos introduciendo un 0, 1, el último elemento y el bit de acarreo» SL0/SL1/SLX/SLA sX · SR0/SR1/SRX/SRA sX
«Rotación» RL sX · RR sX
«Instrucciones lógicas» AND/OR/XOR sX,sY y AND/OR/XOR sX,kk
«Instrucciones de verificación» COMP sX,sY, COMP sX,kk · TEST sX,sY, TEST sX,kk
«Movimiento de registros» LOAD sX,sY · LOAD sX,kk
«Operaciones con puertos» IN sX,(sY), IN sX,kk · OUT sX,(sY), OUT sX,kk
«Operaciones con memoria» FETCH/STORE sX,(sY) y sX,kk
«Instrucciones de saltos» JUMP etiq, JUMP (N)Z, etiq, JUMP (N)C, etiq · CALL igual · RET
«Habilitación y deshabilitación de interrupciones» EINT · DINT · RETI

Lo que hay que sacar de la tabla antes de escribir el programa:

Mapa de puertos y EQU (decláralos en el examen)

Puerto Direcc. Bits
PORT_ENT (entrada) 00H bit0=S · bit1=B · bit2=P · bit3=A · bit4=C
PORT_SAL (salida) 01H bit0=R (recoger/subir) · bit1=E (extender/bajar)
PORT_CTL (salida) 02H bit0=INICIO_2s (flanco de BAJADA) · bit1=RESET_2s (pulso POSITIVO)
PORT_FIN (entrada) 03H bit0=FIN_CUENTA_2s (ALTO al acabar; BAJO al resetear)

En el ensamblador estos puertos se nombran P_ENT, P_SAL, P_CTL, P_FIN por brevedad.

Diagrama lógico (descríbelo/dibújalo — parte del 1,5 p)

  1. Núcleo PicoBlaze en el centro: fichero de registros s0–sF (16×8), ALU de 8 bits con banderas, PC de 10 bits, bus de direcciones de ROM A9–A0 y bus de instrucción de 18 bits, buses de E/S IN_PORT/OUT_PORT de 8 bits, dirección de puerto PORT_ID de 8 bits y strobes READ_STROBE/WRITE_STROBE.
  2. ROM de programa 1024×18 (bloque de memoria FPGA con WE a 0): A9–A0 del núcleo; los 18 bits de la palabra van al registro de instrucción. Posición 03FFH: RETI — sin interrupciones.
  3. Reloj de 10 MHz al CLK del core y al módulo CTR2s (que cuenta internamente 2×10⁷ pulsos = 2,000 s exactos).
  4. Entradas S, B, P (con su acondicionado, activas ALTO) y A, C (finales de carrera) → registro PORT_ENT 00H. Salidas PORT_SAL 01H bit0 (R) y bit1 (E) → etapa de potencia del motor (puente: R=activa recoger, E=activa extender; el software jamás las activa a la vez).
  5. Módulo CTR2s: entradas clk, RESET (pulso 0→1→0: borra y baja FIN), INICIO_2s (arranca en flanco de BAJADA); salida FIN_CUENTA_2s → PORT_FIN 03H bit0. Las dos líneas de control salen del PORT_CTL 02H.
  6. Los pulsos de OUT duran ≈1 instrucción (a 10 MHz, ~400 ns): sobra para módulos síncronos de la misma FPGA.
  7. Decodificación de puertos: con PORT_ID + strobes se seleccionan H"00" y H"03" (carga con READ_STROBE, salen por IN_PORT) y H"01" y H"02" (latch con WRITE_STROBE, mantienen lo escrito).

Diagrama verificado con el que responder (los pines del core son exactamente los del símbolo impreso):

Esquema hardware PicoBlaze de la persiana (octubre-2023, apartado 1c) ROM de programa 1024 x 18 RAM de bloque FPGA, WE a 0 palabra 03FFH = RETI (sin usar) ADDRESS[9:0] instruccion I[17:0] PicoBlaze Microcontroller (simbolo impreso en la hoja del examen) IN_PORT[7:0] INTERRUPT RESET CLK OUT_PORT[7:0] PORT_ID[7:0] READ_STROBE WRITE_STROBE INTERRUPT_ACK IN_PORT[7:0] reset FPGA sin uso (sondeo) OUT_PORT PORT_ID INTERRUPT_ACK: libre DEC:00-03 PORT_ENT H"00" bit0 S · bit1 B · bit2 P bit3 A · bit4 C registro de E/S: se carga con PORT_ID=H"00" y READ_STROBE a 1 (IN) S B P pulsadores nivel ALTO A · C finales de carrera PORT_SAL H"01" bit0 R · bit1 E latch (OUT mantiene) Motor persiana R: recoger (sube) E: extender (baja) nunca R=E=1 (software) PORT_CTL H"02" bit0 INICIO_2s bit1 RESET_2s CTR2s (FPGA) cuenta 20.000.000 pulsos = 2,000 s borra con pulso RESET arranca en BAJADA de INICIO_2s · FIN=1 al acabar PORT_FIN H"03" bit0 FIN_CUENTA_2s ENTRADA (se lee con IN) FIN_CUENTA_2s Reloj 10 MHz a CLK del core y al CTR2s Pines del core = la figura impresa en la hoja: IN_PORT/OUT_PORT y PORT_ID de 8 bits + strobes + INTERRUPT/INTERRUPT_ACK (puertos H"00"-H"03": 4 registros, PORT_ID holgado). INTERRUPT e INTERRUPT_ACK quedan sin usar: la cuenta se sondea por software (decision propia; EINT/DINT/RETI estan en la tabla pero no hacen falta). Reloj: los 20.000.000 de pulsos del CTR2s son los del reloj de 10 MHz (2 s), no instrucciones del micro: el bucle de espera del apartado c no cuenta la pausa.

Ensamblador — bloques ASM 1 a 3 (solo mnemónicos de la tabla de la hoja)

; =====================================================================
; Persiana (octubre-2023, Problema 1c): PicoBlaze + contador externo CTR2s
; Ensamblador de los bloques ASM 1-3 del apartado a (los bloques 4-7 van
; al final como referencia: el enunciado pide traducir solo los 3 primeros)
; UNICOS mnemonicos validos: los de la tabla impresa en la hoja del examen.
; Se usan LOAD, IN, OUT, TEST y JUMP (etiq, Z y NZ).
;
; Puerto lectura   H"00": bit0=S  bit1=B  bit2=P  bit3=A  bit4=C
; Puerto escritura H"01": bit0=R (subir)  bit1=E (bajar)
; Puerto escritura H"02": bit0=INICIO_2s  bit1=RESET_2s
; Puerto lectura   H"03": bit0=FIN_CUENTA_2s
; =====================================================================
P_ENT  EQU H"00"
P_SAL  EQU H"01"
P_CTL  EQU H"02"
P_FIN  EQU H"03"

        ORG H"000"
; ---------------------------------------------------------------------
; BLOQUE ASM 1: ABAJO (estado inicial: persiana totalmente abajo)
; ---------------------------------------------------------------------
ABAJO:  LOAD s1, H"00"     ; R=0, E=0: motor sin accionar
        OUT s1, P_SAL      ; parado asegurado al arrancar
ESP_S:  IN  s0, P_ENT      ; leo S, B, P, A, C en un solo byte
        TEST s0, H"01"     ; pruebo S (bit0): Z=1 mientras S este a 0
        JUMP Z, ESP_S      ; sin pulsar: sigo esperando en ABAJO
; ---------------------------------------------------------------------
; BLOQUE ASM 2: SUBE (R=1 mientras sube; limite y botones cada vuelta)
; ---------------------------------------------------------------------
SUBE:   LOAD s1, H"01"     ; R=1, E=0: la persiana se recoge (sube)
        OUT s1, P_SAL
SUB_L:  IN  s0, P_ENT      ; relectura de sensores en cada vuelta
        TEST s0, H"08"     ; pruebo A (bit3): A=0 solo al llegar arriba
        JUMP Z, ARRIBA     ; arriba: limite con prioridad (bloque 5)
        TEST s0, H"04"     ; pruebo P (bit2): parada en marcha
        JUMP NZ, PARADA    ; P=1 -> bloque 4
        TEST s0, H"02"     ; pruebo B (bit1): inversion en marcha
        JUMP NZ, PARO_2S   ; B=1 -> bloque 3 (pausa de 2 s)
        JUMP SUB_L         ; sigo subiendo
; ---------------------------------------------------------------------
; BLOQUE ASM 3: ESPERA_2S_BAJA (parada + cuenta externa de 2 s)
; ---------------------------------------------------------------------
PARO_2S:
        LOAD s1, H"00"     ; PARO el motor (el enunciado: pausa con motor parado)
        OUT s1, P_SAL
        LOAD s1, H"02"     ; RESET_2s a 1 ...
        OUT s1, P_CTL
        LOAD s1, H"00"     ; ... y a 0: pulso POSITIVO que borra CTR2s
        OUT s1, P_CTL      ; (FIN_CUENTA baja sola con el borrado)
        LOAD s1, H"01"     ; INICIO_2s a 1 ...
        OUT s1, P_CTL
        LOAD s1, H"00"     ; ... y a 0: FLANCO DE BAJADA = arranca la cuenta
        OUT s1, P_CTL
F2S_B:  IN  s2, P_FIN      ; espero FIN_CUENTA_2s por sondeo
        TEST s2, H"01"     ; pruebo bit0: Z=1 mientras FIN este a 0
        JUMP Z, F2S_B      ; aun no cumple la cuenta: bucle
        JUMP BAJA          ; cuenta cumplida -> bloque 6
; =====================================================================
; Bloques 4-7 (referencia; el enunciado solo pide 1-3): misma receta
; =====================================================================
PARADA: LOAD s1, H"00"     ; sin salidas: posicion intermedia parada
        OUT s1, P_SAL
PAR_L:  IN  s0, P_ENT
        TEST s0, H"01"
        JUMP NZ, SUBE      ; S: sube DIRECTO (sin pausa)
        TEST s0, H"02"
        JUMP NZ, BAJA      ; B: baja DIRECTO (sin pausa)
        JUMP PAR_L
ARRIBA: LOAD s1, H"00"     ; arriba del todo (A=0): sin salidas
        OUT s1, P_SAL
ARR_L:  IN  s0, P_ENT
        TEST s0, H"02"
        JUMP NZ, BAJA      ; desde arriba: B DIRECTO (sin pausa)
        JUMP ARR_L
BAJA:   LOAD s1, H"02"     ; E=1, R=0: la persiana se extiende (baja)
        OUT s1, P_SAL
BAJ_L:  IN  s0, P_ENT
        TEST s0, H"10"     ; pruebo C (bit4): totalmente abajo
        JUMP NZ, ABAJO     ; limite abajo con prioridad (bloque 1)
        TEST s0, H"04"
        JUMP NZ, PARADA    ; P=1 -> bloque 4
        TEST s0, H"01"
        JUMP NZ, PARO_2S_S ; S en bajada -> bloque 7 (pausa de 2 s)
        JUMP BAJ_L
PARO_2S_S:                 ; BLOQUE 7: ESPERA_2S_SUBE (igual que el 3)
        LOAD s1, H"00"     ; paro el motor que estaba bajando
        OUT s1, P_SAL
        LOAD s1, H"02"     ; pulso RESET_2s (limpieza ANTES de arrancar)
        OUT s1, P_CTL
        LOAD s1, H"00"
        OUT s1, P_CTL
        LOAD s1, H"01"     ; flanco de BAJADA de INICIO_2s
        OUT s1, P_CTL
        LOAD s1, H"00"
        OUT s1, P_CTL
F2S_S:  IN  s2, P_FIN      ; espero FIN_CUENTA_2s
        TEST s2, H"01"
        JUMP Z, F2S_S
        JUMP SUBE          ; 2 s cumplidos -> sube

Cómo leerlo. Los bloques 1–3 traducidos son ABAJO, SUBE y ESPERA_2S_BAJA (numeración = orden de aparición en el apartado a); los bloques 4–7 van al final solo como referencia (complan el trazado completo de las 9 reglas). En cada bucle el IN está dentro del bucle (relectura de sensores en cada vuelta) y los tests usan máscaras de bit: S=H"01", B=H"02", P=H"04", A=H"08", C=H"10". Ojo: A=0 es arriba del todo, por eso en SUB_L TEST s0,H"08" + JUMP Z, ARRIBA. La secuencia de CTR2s en PARO_2S: parar el motor (OUT máscara H"00") → pulso POSITIVO de RESET (H"02" y luego H"00") → pulso de BAJADA de INICIO (H"01" y luego H"00") → bucle IN/TEST/JUMP Z sondeando el bit0 de FIN. Ninguna ruta escribe R y E a la vez: el enclavamiento del ASM se conserva en el software.

Verificación con mini-emulador (pasa, y las negativas caen)

El bloque asm de arriba se ejecuta en un mini-emulador (Python) que: (1) implementa la tabla de la hoja y aborta si escribes INPUT, OUTPUT, JP, BRANCH, CONSTANT o RETURN; (2) modela el entorno: posición 0–100 (100=arriba con A=0; 0=abajo con C=1), motor que avanza 10 por vuelta de sondeo, pulsadores a nivel y el módulo CTR2s con sus reglas literales (pulso RESET positivo borra y baja FIN, arranque en BAJADA de INICIO, FIN=1 al acabar la cuenta); la cuenta se modela a escala simbólica N2 ≈ 6 sondeos en vez de 20.000.000 — el mismo truco de escala reducida del testbench GHDL del apartado 1.b — y (3) comprueba el trazado exacto contra asserts. Resultado de la ejecución: TRAZADA OK — 67 instrucciones, 302 pasos; 16 escrituras al puerto de salida con las máscaras de las 9 reglas; 12 escrituras a PORT_CTL (3 pulsos completos RESET+INICIO); 18 sondeos de FIN (5 con FIN=0 y el 6º con FIN=1, en cada pausa); el invariante R·E nunca se viola y el motor está parado durante las 3 pausas.

Y para que el verificador no sea un sello de conformidad, se ejecutan 7 mutaciones (cada una un error típico): N1 omitir la bajada del pulso RESET · N2 testear B en vez de A en SUB_L · N3 no apagar el motor antes de arrancar la cuenta · N4 esperar con JUMP NZ (sale al primer sondeo) · N5 lanzar INICIO antes que RESET · N6 saltar a BAJA tras la cuenta que era para subir · N7 escribir s10 (registro inexistente, solo s0–sF). Las 7 caen en los asserts o en el control de tabla. Reproducción: python3 emu_oct23_p1.py guia.md — el mini-emulador extrae solo el bloque asm del markdown (modo guía).

📚 Teoría: Tema 4, pág. 45 del PDF «Tema 4 SD-II_20220512.pdf» — el programa se aloja en un bloque de RAM de la FPGA (el modelo rom_1024x18 con WE a 0: el micro lee instrucciones como una ROM más) 📚 Teoría: Tema 4, págs. 34–35 del PDF «Tema 4 SD-II_20220512.pdf» — conexión de las salidas OUT a la lógica de la FPGA y uso de declaraciones EQU para nombrar los puertos de salida 📚 Teoría: Tema 4, pág. 37 del PDF «Tema 4 SD-II_20220512.pdf» — la única entrada de interrupción y las instrucciones EINT/DINT (aquí no hace falta interrupción: el FIN del contador se sondea con IN)

Errores típicos P1.c


Problema 2 — Mapa de memoria 1M×16 (5 puntos)

Enunciado íntegro del Problema 2 (mapa de memoria para CPU de 1M posiciones × 16 bits): tamaños RAM/ROM/E/S, anclajes y baremo real 0,5+0,5+1+1+1+1. Incluye la tabla de pastillas disponibles, que en el escaneo era una imagen.
Enunciado íntegro del Problema 2 (mapa de memoria para CPU de 1M posiciones × 16 bits): tamaños RAM/ROM/E/S, anclajes y baremo real 0,5+0,5+1+1+1+1. Incluye la tabla de pastillas disponibles, que en el escaneo era una imagen.

El examen subpuntuaria este problema 0,5+0,5+1+1+1+1.

Planteamiento (copia esto al principio). La CPU dirige 2²⁰ = 1M posiciones de 16 bits (bus A19–A0, D15–D0). Ubico la RAM pegada a la dirección 0, la ROM a continuación y el módulo E/S acabando en la última dirección (FFFFFH); calculo los huecos, expando cada región con la fórmula palabras×bits usando Únicamente las pastillas que da la tabla del enunciado, y decodifico con un 3-a-8 sobre A19–A17 más puertas (y su versión FPGA en VHDL).

Datos que fija el enunciado y decisiones de diseño. Fija el enunciado: el espacio de 1M posiciones de 16 bits (bus de direcciones de 20 bits A19–A0 y bus de datos de 16 bits D15–D0); la RAM de 512K×16 a partir de la dirección inicial (0); la ROM de 256K×16 a continuación de la RAM; el módulo de E/S de 16K×16 que termina en la última dirección de memoria (FFFFFH); la tabla de pastillas disponibles — ROM: 128K×1, 64K×8, 128K×8; RAM: 128K×1, 256K×8 (no hay ninguna pastilla para E/S)—; el criterio de diseño «con el menor número de pastillas»; y el baremo: a) 0,5 · b) 0,5 · c) 1 · d) 1 · e) 1 · f) 1 = 5 puntos. No lo fija el enunciado: las señales de control y sus polaridades (la tabla no indica CE/WE en ninguna pastilla). La guía decide —como es habitual— CE de RAM, ROM y módulo E/S activas a nivel BAJO y WE̅ también activa a BAJO, elección coherente con un decodificador 74138 de salidas activas a BAJO; si tu profesor exige CIs activas a ALTO solo cambian las ecuaciones de CE y las burbujas del diagrama, no el mapa ni el número de pastillas. Tampoco fija qué decodificador («usando para la decodificación un decodificador y puertas lógicas»): la guía usa un 3-a-8 (74138) con A19,A18,A17, decisión propia igualmente válida. Y el E/S no es una pastilla: la tabla no ofrece CIs de E/S, así que el módulo de 16K×16 lo construye el propio diseño y cuenta como 1 elemento.

2.a ¿Cabe la memoria? (0,5 p)

RAM 512K + ROM 256K + E/S 16K = 784K posiciones ≤ 1024K = 1M ✓ HAY SOLUCIÓN
Hueco restante = 1024K − 784K = 240K posiciones

En hexadecimal (verificado): 00000H–7FFFFH + 80000H–BFFFFH + FC000H–FFFFFH; hueco C0000H–FBFFFH = FBFFFH−C0000H+1 = 3C000H = 245.760 palabras = 240K (ojo: el hueco es de 240K, NO de 192K — haz la resta en hex en el examen y no repitas la cifra de memoria).

📚 Teoría: Tema 5, pág. 32 del PDF «Tema 5 SD-II_20230215.pdf» — mapa de memoria y capacidad según el bus

2.b Módulos en TODOS los casos y elección (0,5 p)

Tabla ORIGINAL de pastillas del examen (imagen nativa, recuperada por visión): ROM {128K×1, 64K×8, 128K×8} y RAM {128K×1, 256K×8}. El examen no indica señales ni polaridades: la activación BAJA es decisión tuya, declárala.
Tabla ORIGINAL de pastillas del examen (imagen nativa, recuperada por visión): ROM {128K×1, 64K×8, 128K×8} y RAM {128K×1, 256K×8}. El examen no indica señales ni polaridades: la activación BAJA es decisión tuya, declárala.

Fórmula general de expansión (repítela literal, con ella se recalcula cualquier tabla):

Nº CIs de una región = (palabras_region / palabras_CI) × (16 bits / bits_CI)

Aplícala solo a las pastillas que realmente ofrece la tabla del examen (arriba, en negrita): no inventes CIs intermedias. El «en todos los casos» del enunciado obliga a calcular cada combinación ofrecida:

Región CI realmente ofrecida Expansión palabras Expansión bits Nº CIs
RAM 512K×16 256K×8 512/256 = 2 filas 16/8 = 2 en paralelo 4 ← elegida
RAM 512K×16 128K×1 512/128 = 4 filas 16/1 = 16 en paralelo 64
ROM 256K×16 128K×8 256/128 = 2 filas 16/8 = 2 en paralelo 4 ← elegida
ROM 256K×16 64K×8 256/64 = 4 filas 16/8 = 2 en paralelo 8
ROM 256K×16 128K×1 256/128 = 2 filas 16/1 = 16 en paralelo 32
E/S 16K×16 — (la tabla no da pastillas de E/S) módulo propio 16K×16 — 1

Elección más favorable (criterio del enunciado: menor número de pastillas): RAM con CIs de 256K×8 (4 pastillas), ROM con CIs de 128K×8 (4 pastillas) y módulo E/S propio (1 elemento): 9 elementos en total. Muestra siempre la expansión en dos factores (palabras × bits): p. ej. 512K×16 = 2 filas de 256K (extensión) × 2 CIs por fila (extensión de bit, D7-D0 y D15-D8).

La trampa de la tabla son las pastillas «× 1»: una CI de 1 bit de ancho obliga a 16 CIs en paralelo para cubrir el bus de datos (así sale el 64 y el 32 de la tabla: 4×16 y 2×16). La única alternativa real para la RAM es 128K×1 (64 CIs) — 256K×8 y 128K×1 son las dos únicas CIs RAM ofrecidas; ojo de nuevo: 128K×8 y 64K×8 solo se ofrecen como ROM. Si la tabla de tu examen difiere, recalcula con la fórmula — el procedimiento es lo que puntúa.

📚 Teoría: Tema 1, pág. 53 del PDF «Tema 1 SD-II_20200206.pdf» — memorias organizadas en palabras de m bits

2.c Mapa de memoria (1 p)

Dibuja la memoria como una columna de abajo (0) arriba (FFFFFH):

00000H ┌───────────────┐
       │ RAM  512K×16    │ 00000H-7FFFFH  (512K×16 desde la dirección 0)
7FFFFH ├───────────────┤
80000H │ ROM  256K×16    │ 80000H-BFFFFH  (a continuación de la RAM)
BFFFFH ├───────────────┤
C0000H │ hueco   240K    │ C0000H-FBFFFH  (sin asignar)
FBFFFH ├───────────────┤
FC000H │ E/S   16K×16    │ FC000H-FFFFFH  (termina en la última dirección)
FFFFFH └───────────────┘

Cálculos que van en el papel: RAM: 0 + 512K − 1 = 7FFFFH. ROM: 80000H + 256K − 1 = BFFFFH. E/S: FFFFFH − 16K + 1 = FFFFFH − 3FFFH + 1 = FC000H (el E/S se ancla POR ATRÁS).

Esquema del mapa (repásalo antes de dibujarlo a mano en el examen):

📚 Teoría: Tema 5, pág. 33 del PDF «Tema 5 SD-II_20230215.pdf» — ejemplo: RAM al principio, ROM al final

Mapa de memoria 1M posiciones × 16 bits (A19–A0 · D15–D0) — 00000H–FFFFFH inicio posiciones RAM 512K×16 · 00000H–7FFFFH · CE BAJO (por pareja) 2 filas × 2 CI 256K×8 en paralelo = 4 pastillas RAM-A 00000H–3FFFFH · RAM-B 40000H–7FFFFH a partir de la dirección inicial (0) 00000H 7FFFFH 524.288 ROM 256K×16 · 80000H–BFFFFH · CE BAJO (sin WE) 2 filas × 2 CI 128K×8 en paralelo = 4 pastillas ROM-A 80000H–9FFFFH · ROM-B A0000H–BFFFFH 80000H BFFFFH 262.144 Hueco 240K · C0000H–FBFFFH (ninguna CE activa) C0000H FBFFFH 245.760 Módulo E/S 16K×16 · FC000H–FFFFFH · CE BAJO · WE BAJO 1 elemento propio (la tabla no ofrece pastillas de E/S) anclado por detrás: FFFFFH − 3FFFH + 1 = FC000H FC000H FFFFFH 16.384 Totales: 524.288 + 262.144 + 245.760 + 16.384 = 1.048.576 = 1M posiciones ✓ (0 solapes, verificado por barrido de las 2^20 direcciones) 9 elementos: 4 CI RAM 256K×8 + 4 CI ROM 128K×8 + 1 módulo E/S (criterio del enunciado: menor número de pastillas) CE/WE activas BAJAS y decodificador 3–8 sobre A19–A17: decisión propia del resolutor (el examen no fija señales ni polaridades)

2.d Tabla de direccionamiento (1 p)

Con el decodificador 3-a-8 sobre A19,A18,A17 (bloques de 128K, salidas activas BAJAS Y0̅…Y7̅) y la convención de polaridad declarada arriba (decisión propia: CE activas BAJAS):

Direcciones Módulo Pos. CIs Direcciones internas CE (activa BAJO) WE̅
00000H–3FFFFH RAM-A (pareja) 256K 256K×8 ×2 (D7-D0, D15-D8) A17–A0 Y0̅·Y1̅ (AND) WE̅ CPU
40000H–7FFFFH RAM-B (pareja) 256K 256K×8 ×2 A17–A0 Y2̅·Y3̅ (AND) WE̅ CPU
80000H–9FFFFH ROM-A (pareja) 128K 128K×8 ×2 A16–A0 Y4̅ directa — (ROM no escribe)
A0000H–BFFFFH ROM-B (pareja) 128K 128K×8 ×2 A16–A0 Y5̅ directa —
C0000H–FBFFFH hueco 240K — — ninguna activa —
FC000H–FFFFFH Módulo E/S 16K×16 16K 1 A13–A0 NAND(Y7̅, A16, A15, A14) WE̅ CPU

Comprobaciones (dibújalas): 2·262.144 + 2·131.072 + 16.384 + 245.760 = 1.048.576 = 1M ✓ (recuentos verificados por barrido completo de las 2²⁰ direcciones, ver 2.f). Cada CI usa las líneas BAJAS que necesita (256K→A17-A0, 128K→A16-A0, 16K→A13-A0); las de más peso van al decodificador. WE̅ de la CPU va SOLO a las RAM y al módulo E/S — nunca a la ROM.

📚 Teoría: Tema 5, págs. 34–35 del PDF «Tema 5 SD-II_20230215.pdf» — condiciones de habilitación por líneas altas

2.e Diagrama lógico con decodificador + puertas (1 p)

CE_RAM-A_N = Y0̅ · Y1̅                ← ¡AND! con salidas activas a BAJO, una AND saca 0
CE_RAM-B_N = Y2̅ · Y3̅                   si CUALQUIERA de sus entradas está a 0
CE_ROM-A_N = Y4̅                       (uso directo de la salida del 74138)
CE_ROM-B_N = Y5̅
CE_ES_N    = ( Y7̅ · A16 · A15 · A14 )̅  ← NAND de 4 entradas

Los dos ← subrayados son errores reales que cometí en el borrador y cazó el barrido completo de simulación: (i) poner OR donde va AND con lógicas activas a bajo (la OR de Y0̅,Y1̅ solo se activa si AMBAS están seleccionadas: imposible → las RAM nunca se habilitaban); (ii) olvidar A16 en el E/S: sin ella la condición se cumplía también desde EC000H (Y7̅ fija A19-A17, deja A16 libre). Repasa en el papel las fronteras 00000/3FFFF/40000/7FFFF/80000/9FFFF/A0000/BFFFF/FBFFF/FC000/FFFFFH. - Conexiones: A19–A17 → selecciones del 74138; A17–A0 → direcciones de las 4 CIs RAM; A16–A0 → las 4 CIs ROM; A13–A0 → módulo E/S. D7–D0 a las CIs «bajas» de cada pareja y D15–D8 a las «alta»; bus D15–D0 común al módulo E/S. WE̅ de la CPU → pines W̅ de las 4 RAM y del módulo E/S. Y6̅ queda libre (hueco) — dilo.

Diagrama lógico (decodificador 3–8 + puertas + CIs en pareja):

DECODIFICADOR 3–8 + PUERTAS 74138 · salidas Y0_N–Y7_N activas BAJAS Entradas de selección: A19, A18, A17 Siempre habilitado: G1=1 · G2A=G2B=0 Cada Yk_N selecciona un bloque de 128K Y0_N–Y5_N y Y7_N se usan · Y6_N libre las puertas de la derecha dan las CE (dos AND de 2 entradas y una NAND de 4) CE_ROM-A_N = Y4_N · CE_ROM-B_N = Y5_N (uso directo, sin puerta) la NAND toma además A16, A15, A14 Y0_N Y1_N AND CE_RAM-A_N Y2_N Y3_N AND CE_RAM-B_N Y4_N = CE_ROM-A_N (uso directo) Y5_N = CE_ROM-B_N (uso directo) Y6_N libre (hueco sin decodificar) Y7_N A16 A15 A14 NAND CE_ES_N CPU (bus de 20 direcciones y 16 de datos) Buses: A19–A0 (20) · D15–D0 (16) · WE_N (BAJO) A17–A0 a las RAM · A16–A0 a las ROM · A13–A0 al E/S WE_N va solo a las 4 CIs RAM y al módulo E/S D7–D0 a la CI baja de cada pareja · D15–D8 a la alta A19, A18, A17 RAM-A · 00000H–3FFFFH · CE_RAM-A_N (BAJO) RA-a · 256K×8 · D7–D0 A17–A0 · WE_N RA-b · 256K×8 · D15–D8 A17–A0 · WE_N RAM-B · 40000H–7FFFFH · CE_RAM-B_N (BAJO) RB-a · 256K×8 · D7–D0 A17–A0 · WE_N RB-b · 256K×8 · D15–D8 A17–A0 · WE_N ROM-A · 80000H–9FFFFH · CE_ROM-A_N (BAJO) OA-a · 128K×8 · D7–D0 A16–A0 · solo lectura OA-b · 128K×8 · D15–D8 A16–A0 · solo lectura ROM-B · A0000H–BFFFFH · CE_ROM-B_N (BAJO) OB-a · 128K×8 · D7–D0 A16–A0 · solo lectura OB-b · 128K×8 · D15–D8 A16–A0 · solo lectura Hueco 240K · C0000H–FBFFFH: aquí ninguna CE se activa Módulo E/S 16K×16 · FC000H–FFFFFH · CE_ES_N (BAJO) 1 elemento propio (no es pastilla de la tabla) A13–A0 · D15–D0 completos · WE_N CE_ES_N = NAND(Y7_N, A16, A15, A14) Leyenda: sufijo _N = señal activa a nivel BAJO (decisión propia del resolutor: el examen no fija señales ni polaridades) CE_RAM-A_N = Y0_N AND Y1_N · CE_RAM-B_N = Y2_N AND Y3_N · CE_ROM-A_N = Y4_N · CE_ROM-B_N = Y5_N · CE_ES_N = NAND(Y7_N, A16, A15, A14) En cada pareja: compartidas direcciones y CE; una CI aporta D7–D0 y su gemela D15–D8 · la WE_N de la CPU nunca va a la ROM

📚 Teoría: Tema 5, pág. 40 del PDF «Tema 5 SD-II_20230215.pdf» — decodificar con decodificador + puertas lógicas

2.f Módulo VHDL de la FPGA que sustituye al decodificador + puertas (1 p)

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

-- FPGA de decodificacion del mapa 1M x 16 (sustituye al 74138 + puertas)
entity dec_mapa is
    port ( A         : in  std_logic_vector(19 downto 0);
           CE_RAM1_N : out std_logic;   -- 00000H-3FFFFH, activa BAJO
           CE_RAM2_N : out std_logic;   -- 40000H-7FFFFH, activa BAJO
           CE_ROM1_N : out std_logic;   -- 80000H-9FFFFH, activa BAJO
           CE_ROM2_N : out std_logic;   -- A0000H-BFFFFH, activa BAJO
           CE_ES_N   : out std_logic ); -- FC000H-FFFFFH, activa BAJO
end entity;

architecture rtl of dec_mapa is
    -- decodificador 3-8 descrito en puertas (A19,A18,A17; salidas activas BAJAS)
    signal Y0, Y1, Y2, Y3, Y4, Y5, Y6, Y7 : std_logic;
begin
    Y0 <= not (not A(19) and not A(18) and not A(17));
    Y1 <= not (not A(19) and not A(18) and     A(17));
    Y2 <= not (not A(19) and     A(18) and not A(17));
    Y3 <= not (not A(19) and     A(18) and     A(17));
    Y4 <= not (    A(19) and not A(18) and not A(17));
    Y5 <= not (    A(19) and not A(18) and     A(17));
    Y6 <= not (    A(19) and     A(18) and not A(17));
    Y7 <= not (    A(19) and     A(18) and     A(17));

    CE_RAM1_N <= Y0 and Y1;                                  -- AND de activas-BAJO
    CE_RAM2_N <= Y2 and Y3;
    CE_ROM1_N <= Y4;                                         -- uso directo
    CE_ROM2_N <= Y5;
    CE_ES_N   <= not (not Y7 and A(16) and A(15) and A(14)); -- NAND(Y7,A16,A15,A14)
end architecture rtl;

WE̅ no pasa por la FPGA (va directa de la CPU a RAM/E/S); si tu profesor la incluye en el módulo, añádela como entrada y sácala por una salida WE_RAM_N <= WE_N sin más.

Resultado de la verificación (recuento exacto, no muestreo): GHDL 4.1.0 analiza el módulo tal cual y simula un testbench de segmentos representativos (una muestra por cada bloque de 1024 direcciones) sin ningún fallo; el barrido completo de las 1.048.576 direcciones se hace en Python con las mismas ecuaciones del VHDL:

Mal por senal: RAM1=0 RAM2=0 ROM1=0 ROM2=0 ES=0 solapes=0
Recuentos: RAM1=262144 RAM2=262144 ROM1=131072 ROM2=131072 ES=16384 hueco=245760
DECODIFICADOR OK EN LAS 1.048.576 DIRECCIONES
(RAM1+RAM2 512K + ROM 256K + ES 16K + hueco 240K = 1M)

El testbench compara cada CE contra expectativas calculadas por rangos de dirección (independiente de las ecuaciones), recuenta por región y comprueba que nunca hay dos CEs activas a la vez. Truco de examen sin simulador: escribe A19…A14 en binario de cada frontera (FBFFF = 1111 10… → A14=0 → E/S deshabilitado ✓; FC000 = 1111 1100 0… → habilitado ✓) y comprueba que tu ecuación falla justo ahí si le falta una variable.

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

Errores típicos P2

  1. Inventarte CIs que la tabla no ofrece: las únicas RAM son 256K×8 y 128K×1, y las únicas ROM 128K×8, 64K×8 y 128K×1. Con CIs «× 1» la expansión de bits es ×16 (64 y 32 CIs): calcularlas es justo lo que pide el «en todos los casos».
  2. Anclar el E/S delante: el E/S termina en FFFFFH → empieza en FFFFF−3FFF+1 = FC000H. Ponerlo en C0000H te deja mal el mapa entero.
  3. Hueco de 192K de memoria: es 240K (1024−784=240; hex: 3C000H). Haz la resta.
  4. OR en vez de AND al agrupar salidas activas BAJAS del 74138 (RAM1 = Y0̅·Y1̅). Error real cazado en simulación — vale 0.5 p de tabla + diagrama entero mal.
  5. OLVIDAR A16 en el E/S (solo A15·A14 + Y7̅ → se activa desde EC000H, solapando 16K de hueco). Verifica la frontera FBFFFH/FC000H SIEMPRE.
  6. WE̅ conectada a la ROM, o olvidar WE̅ en el módulo E/S (sus registros de control se escriben).
  7. Expansión mal: 512K×16 con CIs de 256K×8 son 4 CIs (2×2), no 2; y las parejas por bit comparten CE pero una va a D7-D0 y la otra a D15-D8.
  8. Reparto de líneas de dirección: la CI de 256K recibe A17-A0 (no A19-A2 ni A18: esas van al decodificador como AND de CE); la de 128K recibe A16-A0; el E/S A13-A0.
  9. Poner la CE de RAM como una sola señal para las dos mitades: las CIs de 256K×8 no pueden compartir CE en todo 00000-7FFFFH (alias/solape con la otra pareja) — van CE_RAM-A y CE_RAM-B separadas.
  10. Presentar las CEs activas BAJAS como si vinieran del enunciado: el examen no da señales; escríbelas siempre como convención tuya y serán válidas.

Esquema-resumen de la metodología

  1. Derivar el espacio de la CPU de los buses — 20 líneas de dirección → 2²⁰ = 1M posiciones; palabra de 16 bits (A19–A0, D15–D0); mapa 00000H–FFFFFH.
  2. Calcular inicio/fin de cada bloque según su anclaje — RAM en 0 (00000H–7FFFFH), ROM a continuación (80000H–BFFFFH) y E/S anclado POR DETRÁS (FFFFFH−3FFFH+1 = FC000H); el hueco (C0000H–FBFFFH) sale solo: haz la resta en hex (3C000H = 240K).
  3. Comprobar la cabida — 784K ≤ 1M y tamaño = final − inicio + 1 en cada fila.
  4. Calcular el nº de CIs EN TODOS los casos con la tabla real de pastillas — fórmula (palabras × bits), sin inventarte CIs: las «× 1» obligan a ×16 en paralelo (64 y 32 CIs).
  5. Elegir la opción más favorable — criterio del enunciado (menor nº de pastillas): 4 RAM 256K×8 + 4 ROM 128K×8 + 1 módulo E/S propio = 9 elementos.
  6. Declarar tus decisiones donde el examen calla — polaridades CE/WE activas BAJAS y decodificador 3–8 (74138) sobre A19,A18,A17: el examen no fija señales; escríbelo como convención tuya.
  7. Escribir la tabla de direccionamiento — direcciones internas por tamaño (256K→A17–A0, 128K→A16–A0, 16K→A13–A0) y CS: Y0̅·Y1̅ y Y2̅·Y3̅ (AND de activas BAJAS), Y4̅/Y5̅ directas y NAND(Y7̅,A16,A15,A14) para el E/S.
  8. Dibujar el diagrama lógico completo — CPU, decodificador siempre habilitado, puertas por CE, parejas de CIs compartiendo direcciones y CE (una D7–D0, su gemela D15–D8); WE̅ solo a RAM y E/S; Y6̅ libre (dilo).
  9. Pasar la decodificación a VHDL — 3–8 en puertas + una expresión concurrente por CE, salidas activas BAJAS; analizar y simular con GHDL.
  10. Barrer las 1.048.576 direcciones — cada CE exacta en su rango, conteos 262.144×2 + 131.072×2 + 16.384 + hueco 245.760 y 0 solapes: es lo que caza el OR↔AND y el A16 olvidado (activación fantasma desde EC000H).

Idea transversal: el mapa lo fijan solo los anclajes del enunciado y la tabla real de pastillas; decodificador y polaridades son decisión propia; y todo se valida barriendo todas las direcciones — no probando cuatro sueltas.


Resumen de baremo y tiempos recomendados (120 min)

Apartado Sub-puntos Tiempo
P1.a ASM (9 conductas + 2·10⁷ con bits) 2,5 30 min
P1.b VHDL (3 procesos + contador 2 s) 1,5 20 min
P1.c PicoBlaze (diagrama + 3 bloques comentados) 1,5 25 min
P2.a+c cabida + mapa 1,5 10 min
P2.b módulos (fórmula + elección) 0,5 5 min
P2.d+e tabla + diagrama (¡AND con activas-bajas y A16!) 2 20 min
P2.f VHDL FPGA 1 10 min

Antes de entregar, comprueba en 2 minutos: (1) en el P1 que A=0 para arriba, que la pausa de 2 s solo aparece en las inversiones en movimiento, y que R·E=00 siempre; (2) en el P2 las fronteras FBFFF/FC000 y la suma de posiciones = 1M.

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.