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)
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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 |
Claves del planteamiento (lo que puntúa):
- A funciona al revés de lo instintivo: parada arriba ⇔ A=0; parada abajo ⇔ C=1. Es la trampa central del examen. Escribe la tabla de verdad de los finales de carrera.
- La pausa de 2 s solo va en las transiciones B-durante-SUBE y S-durante-BAJA (bloques 3 y 7). Desde ARRIBA→BAJA, desde ABAJO→SUBE y desde PARADA→SUBE/BAJA no hay pausa: el motor estaba ya parado. Por eso PARADA es un bloque aparte de ESPERA_2S_*: cubre las reglas 7 y 8 ("directo, sin pausa").
- Límites con prioridad sobre los botones dentro de SUBE y BAJA (regla 9): si a la vez A=0 y B=1, manda el límite (decláralo en una línea).
- Contador 2 s COMPARTIDO por los dos bloques ESPERA: basta uno porque nunca están
activos a la vez, y se pone a cero al salir del estado ESPERA (en la simulación: limpiar
cuando
estado /= ESPERA_*). Dos contadores también es válido (patrón junio-2024) pero hay que limpiar entre cuentas. - Enclavamiento: R y E nunca simultáneas — se cumple gratis definiendo las salidas por estado (R=1 solo en SUBE, E=1 solo en BAJA). Dilo: es un requisito de seguridad.
- El estado PARADA es "intermedia" porque solo se entra desde SUBE/BAJA antes del límite; no hace falta sensor de posición intermedia: lo conoce la máquina.
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
- 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.
- R y E simultáneas (salidas asociadas al botón en vez de al estado, o
elsifmal encadenado): el enclavamiento es de seguridad y se comprueba con el monitor de simulación. - 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.
- 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.
- No escribir la descomposición 2×10⁷ = 10⁶×20 con los bits (20+5) — es parte del apartado a.
- Contador compartido sin limpiar al salir de ESPERA: la segunda pausa arrancaría con
el resto de la primera. Limpieza por
estado /= ESPERA_*. - Proceso combinacional sin valores por defecto (latches en R/E),
caseincompleto, 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:
- Registros solo s0–sF (16×8). Constante = el inmediato
kk(en la hojaH"00"; elk'00'de KCPSM6 no está). OUT sX,kkescribe el CONTENIDO desXen el puertokk: el dato va primero y el puerto después (al revés que en KCPSM6OUT puerto,sX). Para escribir una constante: primeroLOAD s1,H"xx"y luegoOUT s1,puerto(no existeCONSTANT).TEST sX,kkhace AND sin guardar (sX se conserva) y actualiza banderas: Z=1 si el resultado es 0.COMPcompara igual sin guardar. Saltos condicionales solo con Z/NZ y C/NC (las condicionesFC/CSde KCPSM6 no existen en la tabla).- No existen (no vale escribirlos):
INPUT,OUTPUT,JP,BRANCH,RETURN(la tabla diceRET),CONSTANT. Usarlos es responder con un juego de instrucciones que el examen no da. - La tabla sí trae
EINT/DINT/RETI, pero no los uso: el FIN de cuenta se sondea conIN/JUMP Z(decisión propia que hay que declarar; las patillasINTERRUPTeINTERRUPT_ACKdel core quedan sin conectar). - El diagrama impreso del core se titula «PicoBlaze Microcontroler» (sic, errata del
original) y las strobes son
READ_STROBE/WRITE_STROBE;PORT_ID[7:0]es de 8 bits: caben holgadamente 4 registros de puerto H"00"–H"03".
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)
- 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_PORTde 8 bits, dirección de puertoPORT_IDde 8 bits y strobesREAD_STROBE/WRITE_STROBE. - ROM de programa 1024×18 (bloque de memoria FPGA con
WEa 0): A9–A0 del núcleo; los 18 bits de la palabra van al registro de instrucción. Posición 03FFH:RETI— sin interrupciones. - Reloj de 10 MHz al CLK del core y al módulo CTR2s (que cuenta internamente 2×10⁷ pulsos = 2,000 s exactos).
- 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).
- 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. - Los pulsos de
OUTduran ≈1 instrucción (a 10 MHz, ~400 ns): sobra para módulos síncronos de la misma FPGA. - Decodificación de puertos: con
PORT_ID+ strobes se seleccionan H"00" y H"03" (carga conREAD_STROBE, salen porIN_PORT) y H"01" y H"02" (latch conWRITE_STROBE, mantienen lo escrito).
Diagrama verificado con el que responder (los pines del core son exactamente los del símbolo impreso):
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
- Escribir con mnemónicos de KCPSM6 (
INPUT/OUTPUT,JP,BRANCH,CONSTANT,k'00', condicionesFC/CS): la hoja daIN/OUT,JUMP etiquetayJUMP (N)Z/JUMP (N)C,LOAD sX,H"xx", yRETen vez deRETURN. Responder con el otro juego es responder con instrucciones que el examen no da. - Invertir el
OUT: en la tabla de la hoja el dato va primero —OUT s1,P_SAL(escribe el contenido de s1 en el puerto);OUT puerto,s1está al revés. - Disparar INICIO_2s con 0→1 en vez de 1→0: son dos
OUTy el flanco importa (decláralo: INICIO por bajada, RESET por pulso positivo). - Omitir el RESET antes de INICIO: FIN_CUENTA quedó en 1 de la cuenta anterior y el bucle de espera sale al primer sondeo → la pausa de 2 s no se espera.
- Hacer la cuenta 2 s en software sin justificarlo (5 M de instrucciones) o sin declarar la propuesta del contador externo: es el patrón del curso y es evaluable.
- Olvidar el
LOAD s1,H"00"+OUT s1,P_SALal entrar en PARO_2S (el enunciado obliga a parar el motor durante la pausa). - No marcar qué 3 bloques ASM se traducen (numeración = orden de aparición del apartado a).
- En el bucle de SUBE, no re-leer A/C en cada vuelta (el
INva DENTRO del bucle). - Testear A como «¿A=1?» con
JUMP NZa ARRIBA: A=0 es llegar arriba (trampa de nuevo). - Usar
EINT/interrupción por FIN_CUENTA sin declararlo: aquí el FIN se sondea por software y las patillas INTERRUPT/INTERRUPT_ACK quedan libres (válito y más simple; pero hay que decirlo).
Problema 2 — Mapa de memoria 1M×16 (5 puntos)

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)

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
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)
- Decodificador 3-a-8 (74138, salidas activas BAJAS — decisión propia, coherente con la polaridad CE BAJO declarada) con A19, A18, A17 en las entradas de selección y las habilitaciones fijas (G1=1, G̅2A=G̅2B=0): habilitado siempre, los 8 bloques de 128K se usan todos: Y0̅ 00000-1FFFFH, Y1̅ 20000-3FFFFH, Y2̅ 40000-5FFFFH, Y3̅ 60000-7FFFFH, Y4̅ 80000-9FFFFH, Y5̅ A0000-BFFFFH, Y6̅ C0000-DFFFFH, Y7̅ E0000-FFFFFH.
- Ecuaciones de habilitación (con salida activa BAJA; el E/S fija A19…A14=111111: FC000H = 1111 1100 0000 0000 0000B, así que A19,A18,A17 (que da Y7̅) + A16·A15·A14):
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):
📚 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
- 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».
- 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.
- Hueco de 192K de memoria: es 240K (1024−784=240; hex: 3C000H). Haz la resta.
- 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.
- OLVIDAR A16 en el E/S (solo A15·A14 + Y7̅ → se activa desde EC000H, solapando 16K de hueco). Verifica la frontera FBFFFH/FC000H SIEMPRE.
- WE̅ conectada a la ROM, o olvidar WE̅ en el módulo E/S (sus registros de control se escriben).
- 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.
- 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.
- 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.
- 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
- 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.
- 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).
- Comprobar la cabida — 784K ≤ 1M y tamaño = final − inicio + 1 en cada fila.
- 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).
- 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.
- 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.
- 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.
- 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).
- Pasar la decodificación a VHDL — 3–8 en puertas + una expresión concurrente por CE, salidas activas BAJAS; analizar y simular con GHDL.
- 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.