Guía de resolución — Examen de Sistemas Digitales II, Junio 2022 (15-06-2022)
Guía de resolución en construcción. El examen lo redactó Andrés Mejías Borrero y consta de 3 problemas que suman 10 puntos:
| # | Puntos | Tipo |
|---|---|---|
| 1 | 4,0 (ASM 2,5 + VHDL 1,5) | Control de proceso con PLC: grúa que sumerge piezas en un baño químico (sensores L, M, N, E, F; interruptor T; pulsador P; luz verde V; salidas S, B, D, I; 7 segmentos) |
| 2 | 3,5 (hardware 1 + ensamblador 2,5) | El mismo proceso con microcontrolador picoBlaze (el examen incorpora la tabla de instrucciones y el diagrama de bloques KCPSM3) |
| 3 | 2,5 | Mapa de memoria 1M×16 con RAM, ROM y módulo E/S |
Estado de esta guía: publicados los 3 de 3: Problema 1 (grúa en ASM + VHDL al estilo de clase, verificado con GHDL mediante un testbench que recorre el ciclo completo con T=1, el bypass con T=0, el «dedo pegado» y el reset a mitad), Problema 2 (picoBlaze, con auditoría visual de la tabla de instrucciones impresa y diagrama hardware propio, programa verificado con un mini-emulador KCPSM3) y Problema 3 (resuelto y verificado).
Importante: el profesor no puntúa ejercicios mal planteados. Escribe siempre el planteamiento (2-3 frases) antes de desarrollar, justifica cada elección y deja verificable el resultado final (tablas, direcciones, código).
Supuestos declarados
- Orden «justo antes» (ambigüedad del enunciado, SUPUESTO a confirmar con el profesor). El enunciado dice: «la RAM ocupe las posiciones más bajas del mapa de memoria, y justo antes debe situarse la ROM. El módulo de E/S debe ir justo antes de la ROM». Si «antes» se lee en direcciones decrecientes, la frase se contradice a sí misma (nada puede quedar por debajo de las posiciones más bajas). La lectura coherente —y la que usa este profesor en otros exámenes (julio-2023 «justo detrás de la EPROM», julio-2024 «justo después» y junio-2026 «a continuación de», siempre en direcciones crecientes)— es que el profesor enumera el mapa de arriba (direcciones altas) hacia abajo: «justo antes» = inmediatamente por encima. Orden ascendente resultante: RAM (más bajas) → ROM justo detrás → E/S justo detrás de la ROM. Confírmalo con el profesor antes de dar el orden por cerrado.
- Colocación exacta del E/S. El módulo de 16 posiciones se pega inmediatamente detrás de la ROM (C0000H–C000FH), fiel a «justo antes de la ROM» en la lectura del supuesto 1. Pegarlo al final del mapa (FFFF0H–FFFFFH) dejaría un hueco entre ROM y E/S y violaría esa frase.
- Estructura del decodificador (apartados b–d): el enunciado no impone circuitos de decodificación; la guía usa ecuaciones combinacionales directas con las líneas altas A19–A4 (compuertas en c) y módulo VHDL en d)). Un decodificador MSI (p. ej. 3–8 sobre A19, A18, A17) más puertas es alternativa igualmente válida.
No son supuestos —los fija el examen y hay que respetarlos sí o sí: datos de 16 bits y direcciones de 20 bits; 512 K posiciones RAM, 256 K posiciones ROM y E/S de 16 posiciones con CS activa a nivel ALTO; en la tabla de CIs, las ROM tienen CS activa a nivel ALTO y las RAM a nivel BAJO; baremo 0,5 + 0,5 + 1,0 + 0,5 = 2,5.
Problema 1 — Grúa del baño químico: ASM + VHDL (4 puntos)

Enunciado (literal de la hoja del examen). «1. (4 puntos) En el proceso industrial de la figura, algunas piezas deben ser sometidas a un tratamiento especial introduciéndolas en una solución química. Para ello se han instalado los siguientes elementos: un interruptor T, cuya puesta a uno por parte de un operario indica al sistema de control que la pieza debe ser sumergida en la solución; un pulsador P que debe ser accionado por el operario, para que el proceso continúe, después de enganchar la pieza en la posición de origen y de desengancharla en la de destino; una señal luminosa de color verde V, que cuando se encuentra activada indica al operario que puede manipular el gancho con seguridad para enganchar y desenganchar la pieza; tres sensores L, M, y N, que se activan cuando el carro de la grúa está ubicado debajo de los mismos; dos sensores E y F, que detectan cuando el gancho de la grúa se encuentra en sus posiciones más baja y más alta, respectivamente; un sistema de tracción que desplaza el carro a la izquierda y a la derecha al activar las señales I y D, respectivamente; un cilindro que hace subir y bajar el gancho al activar las señales S y B, respectivamente; un visualizador de 7 segmentos que indicará la fase en la que se encuentra el sistema: «P» cuando está parado en la posición inicial; «b» cuando una pieza está realizando el tratamiento con la solución (durante el tiempo en que el sistema está en la vertical del baño químico); «d» cuando está parado en el destino; «U» cuando está volviendo a la posición inicial. El funcionamiento del sistema debe ser el siguiente: una vez que el operario ha colocado el interruptor T en la posición adecuada, según se deba aplicar el tratamiento químico a la pieza o no, éste procede al enganche manual de la misma y a continuación activa el pulsador P. Cuando esto suceda, la pieza debe subir, y en su recorrido hasta la posición de destino debe sumergirse en la solución si así se ha indicado previamente mediante el interruptor T. Al llegar la pieza a la posición de destino, el operario la desenganchará manualmente y una vez hecho esto pulsará de nuevo P, con lo que la grúa retornará a la posición indicada en la figura, donde permanecerá hasta el comienzo de un nuevo ciclo para tratar la pieza siguiente. La luz verde se activará cuando el sistema se encuentra listo para enganchar o desenganchar una pieza. El resto del tiempo permanecerá apagada. Realizar el sistema de control del proceso. Se pide: a) Diagrama ASM de funcionamiento del sistema de control (2,5 puntos). b) Módulo VHDL que represente el diagrama ASM diseñado (1,5 puntos).»
Datos que fija el enunciado y decisiones de diseño
Fija el enunciado: el proceso completo de la figura — L bajo Origen, M bajo la Solución y N bajo Destino, E/F = tope bajo/alto del gancho, I/D = tracción del carro, S/B = cilindro, T = «esta pieza se sumerge», P = «continúa» (se pulsa dos veces por ciclo: tras enganchar en origen y tras desenganchar en destino) y V = «puedes tocar el gancho con seguridad, el resto del tiempo apagada»; el visualizador muestra exactamente cuatro letras P, b, d, U y «b» dura «el tiempo en que el sistema está en la vertical del baño químico»; el ciclo arranca y termina «en la posición indicada en la figura»: el dibujo (recorte nativo
figuras/jun22/recortes/figura-p1-grua-nativa.jpg, renderizado del PDF a 200 ppp y auditado a visión) muestra el carro en L con el gancho abajo sobre la pieza — esa es la posición inicial; y el baremo a) 2,5 p + b) 1,5 p = 4,0 p (sin erratas).No lo fija el enunciado (supuestos y decisiones de la guía, documentados):
- T se muestrea al pulsar P y queda enclavado para todo el ciclo (registro
trat). El enunciado dice que el operario coloca T «previamente» y luego engancha y pulsa: el valor que manda es el del instante de la pulsación, y si el operario mueve T durante el trayecto el ciclo no cambia a mitad (lectura del proceso: la decisión sobre la pieza ya se tomó). Alternativa defendible: consultar T en la vertical del baño (es lo que hace el programa picoBlaze del P2, que no tiene registro de ciclo); con T estable durante el ciclo —el caso que describe el enunciado— ambas lecturas son idénticas. La divergencia está documentada enguias/NOTAS-elaboracion-junio-2022.md.- P se responde por frente de subida; L, M, N, E y F se leen por nivel. El pulsador es la orden de un operario que puede mantenerlo pegado (el propio examen exige dos pulsaciones por ciclo): un frente = una fase. En cambio E, F, L, M y N son finales de carrera: sensores de posición con nivel estable mientras el tope está pisado — no hay que detectarles flancos, hay que esperar su nivel (contrasta con el sensor S de la cinta de junio-2023, que era un pulso de duración indeterminada y allí sí hacía falta el frente). P y T son entradas asíncronas: se sincronizan con 2 FF antes de tocar la lógica. Alternativa equivalente al frente: estados intermedios que esperan la suelta de P (patrón antirrebote del Tema 3); declara la que uses y no mezcles.
- Once bloques ASM, uno por fase del proceso; el nombre del bloque ES el nombre del estado VHDL. No hay contador separado: el «dónde estoy» ya está codificado en el estado.
- La seguridad del proceso va en la estructura de la ASM: el cilindro SIEMPRE sube al tope alto F antes de cualquier I o D, y solo baja con el carro parado en una marca. Arrastrar la pieza con el gancho abajo es imposible por construcción, no por suerte. La verde V es salida Moore únicamente de
PARADOyDESTINO, los dos estados manipulables.- No hay temporizador de tratamiento. El examen no da ni un segundo ni una frecuencia: la sumersión «mantiene el tiempo en que el sistema está en la vertical del baño» — dura lo que tarda el cilindro en bajar a E y volver a F. Quien ponga un contador de N segundos está inventando un dato.
- Visualizador: salida de 7 bits
{a,b,c,d,e,f,g}con tabla propia declarada abajo (encendido = 1; con visualizador de ánodo común se invierten los 7). En los bloques de traslado que el enunciado no asigna a ninguna letra, el bloque conserva la última letra definida (criterio latch, igual que hace el programa del P2); «b» solo aparece si el latch del tratamiento vale 1: con T=0 el cruce de la vertical no es tratamiento y la pantalla no debe escribir 'b'. Los códigos del P2 (ánodo común, H"88"/H"83"/H"91"/H"C1") usan la misma asignación de segmentos para b, d y U; solo difieren en la letra P (los suyos encienden además el segmento c). El examen no fija la tabla: cualquiera de las dos vale si se declara.- En destino el gancho baja a E antes de dar V=1 (bloques
BAJA_DESTINO→DESTINO): desenganchar es la misma operación física que enganchar, y la figura dibuja Origen y Destino a la misma altura. El programa picoBlaze publicado en P2 da V=1 con el gancho aún en F — el ASM aquí es la lectura más física y el TB lo verifica; divergencia documentada en las notas.- Con T=0 el carro cruza M sin parar (decisión vectorial en
IDA_A_M): el enunciado solo manda sumergirse «si así se ha indicado»; parar en seco sobre el baño sin tratamiento es un movimiento que nadie pidió (el P2 sí para en M porque su bifurcación está en ese alto).resetsíncrono obligatorio (el ASM no lo pide; lo añade la traducción del Tema 3 a VHDL): mientrasreset=1el registro vuelve aPARADOy las salidas quedan en reposo (verde apagada); al soltarlo, la ramaPARADOenciende la verde en el siguiente CLK.
Planteamiento. El control es una ASM con un bloque por fase: parada en origen con verde,
subida del gancho, traslado a la vertical del baño con la bifurcación de T (bajar a E y retirar a
F, o cruzar sin parar), traslado a destino, bajada y parada con verde, segunda pulsación, retorno
a L y bajada del gancho vacío. Las salidas I, D, S, B, V y el patrón del visualizador van dentro
de la caja de cada estado (Moore); las decisiones E, F, L, M, N son niveles de finales de carrera
y la de P es un frente, con T enclavado al arrancar el ciclo. El VHDL es la traducción directa:
un único proceso secuencial (wait until clk = '1' y reset síncrono, el patrón de las págs.
30–32 del Tema 3) en el que viven también los sincronizadores antirrebote y el latch de T; las
salidas Moore se escriben dentro de la rama de cada estado.
a) Diagrama ASM — 11 bloques (2,5 p)
Bloques ASM (uno por fase; entre corchetes las salidas activas del estado; sin transición = permanecer):
| # | Bloque ASM (estado) | Salidas del estado | Decisiones → siguiente estado |
|---|---|---|---|
| 1 | PARADO — en L, gancho abajo (E=1) |
V=1, display 'P' | frente de P → SUBE_GANCHO (enclava T en trat) |
| 2 | SUBE_GANCHO — la pieza sube |
S=1 · display 'P' | F=1 → IDA_A_M |
| 3 | IDA_A_M — derecha hacia el baño |
D=1 · display 'P' | M=1 y trat=1 → BAJA_BANO · M=1 y trat=0 → IDA_A_N |
| 4 | BAJA_BANO — parado en M, baja a E |
B=1 · display 'b' | E=1 → SUBE_BANO |
| 5 | SUBE_BANO — retirada del baño |
S=1 · display 'b' | F=1 → IDA_A_N |
| 6 | IDA_A_N — derecha hacia destino |
D=1 · display 'b' (trat=1) o 'P' (trat=0) | N=1 → BAJA_DESTINO |
| 7 | BAJA_DESTINO — parado en N, baja a E |
B=1 · display 'd' | E=1 → DESTINO |
| 8 | DESTINO — listo para desenganchar |
V=1, display 'd' | frente de P → SUBE_RETORNO |
| 9 | SUBE_RETORNO — gancho vacío sube |
S=1 · display 'd' | F=1 → RETORNO |
| 10 | RETORNO — izquierda hacia L |
I=1 · display 'U' | L=1 → BAJA_ORIGEN |
| 11 | BAJA_ORIGEN — gancho vacío baja en L |
B=1 · display 'U' | E=1 → PARADO |
Claves del planteamiento (lo que puntúa):
- Solo P lleva «frente» en sus transiciones; E, F, L, M y N se etiquetan como niveles
(
F=1,E=1,M=1…): son topes de posición que permanecen activos mientras el carro o el gancho están debajo. Con nivel en P, un operario que mantenga el dedo pegado re-dispararía fases; con frente, una pulsación = una transición y el segundo arranque exige una pulsación nueva (el ciclo del enunciado tiene exactamente dos pulsaciones por pieza). - El valor de T se toma al pulsar P (transición
PARADO→SUBE_GANCHO) y la bifurcación de la vertical usa el latchtrat: si no se enclava, mover T durante el trayecto cambia el ciclo en marcha; el enunciado dice que la decisión se tomó «previamente». - En
IDA_A_Mla decisión es doble (M y trat): por eso hay dos salidas etiquetadas; al volver de la inmersión se entra enIDA_A_N, no otra vez enIDA_A_M, para que el carro no vuelva a picar la marca M y re-activar la bajada (lazo infinito de sumersiones). Vsolo enPARADOyDESTINO: es la condición de seguridad del operario; durante la subida, el trayecto, la inmersión y el retorno debe estar apagada («el resto del tiempo permanecerá apagada»).- Secuencia vertical obligatoria en cada traslado: subir a F antes de dar D o I, y bajar a E solo con el carro detenido en L, M o N. Esto hace imposible arrastrar la pieza (o el gancho) contra el borde del baño.
BAJA_ORIGENno es decorativo: al cerrar el ciclo el gancho debe quedar abajo en L — la posición inicial que dibuja la figura y que el TB de verificación comprueba literal.
Tabla del visualizador (decisión 6): {a,b,c,d,e,f,g} con 1 = encendido —
| Letra | a | b | c | d | e | f | g |
|---|---|---|---|---|---|---|---|
| 'P' parado inicial | 1 | 1 | 0 | 0 | 1 | 1 | 1 |
| 'b' tratamiento | 0 | 0 | 1 | 1 | 1 | 1 | 1 |
| 'd' parado destino | 0 | 1 | 1 | 1 | 0 | 1 | 1 |
| 'U' volviendo | 0 | 1 | 1 | 1 | 1 | 1 | 0 |
Ejemplo de recorrido (T=1): PARADO[V=1,'P'] —(pulsa P)→ SUBE_GANCHO[S↑ hasta F] →
IDA_A_M[D hasta M] → BAJA_BANO['b', B hasta E: pieza sumergida] → SUBE_BANO[S hasta F] →
IDA_A_N[D hasta N] → BAJA_DESTINO[B hasta E] → DESTINO[V=1,'d'] —(desengancha y pulsa P)→
SUBE_RETORNO → RETORNO['U', I hasta L] → BAJA_ORIGEN[B hasta E] → PARADO. Con T=0 el
único cambio es IDA_A_M→IDA_A_N sin bajar: nunca aparece 'b' en la pantalla.
📚 Teoría: Tema 3, págs. 15–19 del PDF «Tema 3 SD-II_20200413.pdf» — cajas de estado, selección y condición; el bloque ASM es lo que hay entre dos cajas de estado. 📚 Teoría: Tema 3, pág. 25 del PDF «Tema 3 SD-II_20200413.pdf» — errores comunes: registrar los puertos de entrada como señales internas antes de usarlos. 📚 Teoría: Tema 3, pág. 26 del PDF «Tema 3 SD-II_20200413.pdf» — antirrebote: actuar una sola vez por pulsación y esperar el rearme.
b) Módulo VHDL del ASM (1,5 p)
📚 Teoría: Tema 3, págs. 23–24 del PDF «Tema 3 SD-II_20200413.pdf» — diagrama ASM y módulo VHDL equivalente, el uno junto al otro. 📚 Teoría: Tema 3, págs. 30–32 del PDF «Tema 3 SD-II_20200413.pdf» — traducción de la ASM a VHDL como diagrama de estados, añadiendo reloj y reset a la tarjeta identificativa.
Analizado con GHDL 4.1.0 (--std=08) y verificado con un testbench que modela los
sensores por niveles de final de carrera (los pone a 1 al llegar a la vertical/tope y los
baja al despegar). Escenarios y lo que comprueba cada uno, con asserts severity failure:
reset (salidas en reposo y, al soltarlo, PARADO con verde y pantalla 'P'); ciclo completo
con T=1 paso a paso (subida, IDA_A_M con D, BAJA_BANO con pantalla 'b', inmersión,
segundo traslado, BAJA_DESTINO con 'd', DESTINO con verde, segundo toque, retorno con
'I' y 'U', vuelta a PARADO); ciclo con T=0 (en M pasa de largo: D=1, B=0, nunca pantalla
'b'); «dedo pegado» (P mantenida desde el primer toque hasta DESTINO: dispara UNA vez, no
re-dispara el retorno, y soltarla después tampoco dispara); y reset a mitad del trayecto
(salidas quietas y PARADO recuperado al soltar). Resultado: todos los escenarios OK,
secuencias de pantalla P→b→d→U→P exactas. El detector de frente p2 and not p3 vive dentro
del proceso único: el case lee los sincronizadores del flanco anterior, así que un toque
de un solo CLK produce exactamente un disparo. Registro en las notas de elaboración: la
verificación rica anterior (modelo físico paso a paso + espejo de las reglas literales +
tres mutaciones) se ejecutó contra la estructura previa de dos procesos y está pendiente
de rehacerse contra esta; la re-verificación actual cubre los cuatro escenarios citados.
-- grua.vhd -- Junio-2022 Problema 1: control ASM de la grua del bano quimico
-- Diagrama ASM de 11 bloques; salidas Moore dentro de cada estado.
-- Estructura de clase (Tema 3, pags. 30-32): UN proceso secuencial con reloj y
-- reset; el sincronizador de entradas sigue el patron antirrebote del Tema 3.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity Grua is
port (
clk, reset : in std_logic;
T, P : in std_logic; -- interruptor, pulsador
L, M, N : in std_logic; -- carro bajo origen / bano / destino
E, F : in std_logic; -- gancho abajo / arriba
I, D, S, B : out std_logic; -- traccion izq/der, cilindro sube/baja
V : out std_logic; -- luz verde: se puede manipular el gancho
seg : out std_logic_vector(6 downto 0) -- visualizador {a,b,c,d,e,f,g}, 1=encendido
);
end entity Grua;
architecture ASM of Grua is
-- los 11 bloques del diagrama ASM
type mis_estados is (PARADO, SUBE_GANCHO, IDA_A_M, BAJA_BANO, SUBE_BANO,
IDA_A_N, BAJA_DESTINO, DESTINO, SUBE_RETORNO, RETORNO, BAJA_ORIGEN);
signal estado : mis_estados;
signal trat : std_logic; -- T muestreado al pulsar P: latch del ciclo
-- sincronizador de 2 FF (entradas asincronas) + retardo extra para el flanco de P
-- (mismo patron que el antirrebote del Tema 3, pags. 30-32; van en el proceso unico
-- para que el muestreo de p2/p3 sea determinista: el case ve los valores del flanco anterior)
signal p1, p2, p3 : std_logic;
signal t1, t2 : std_logic;
-- patrones del visualizador: encendido = 1 (anodo comun: se invertirian los 7 bits)
constant PAT_P : std_logic_vector(6 downto 0) := "1100111"; -- 'P': a,b,e,f,g
constant PAT_B : std_logic_vector(6 downto 0) := "0011111"; -- 'b': c,d,e,f,g
constant PAT_D : std_logic_vector(6 downto 0) := "0111011"; -- 'd': b,c,d,f,g
constant PAT_U : std_logic_vector(6 downto 0) := "0111110"; -- 'U': b,c,d,e,f
begin
------- proceso secuencial UNICO: sincronizadores + estado + latch + salidas Moore -------
process
begin
wait until clk = '1';
p1 <= P; p2 <= p1; p3 <= p2; -- un frente de P = una actuacion del operario
t1 <= T; t2 <= t1; -- (el pulso puede mantenerse: solo cuenta el frente)
if reset = '1' then
estado <= PARADO; trat <= '0';
p1 <= '0'; p2 <= '0'; p3 <= '0'; t1 <= '0'; t2 <= '0';
I <= '0'; D <= '0'; S <= '0'; B <= '0'; V <= '0';
seg <= PAT_P;
else
case estado is
when PARADO => -- en L, gancho abajo (E), listo p/ enganchar
I <= '0'; D <= '0'; S <= '0'; B <= '0';
V <= '1'; seg <= PAT_P; -- pantalla 'P'
if p2 = '1' and p3 = '0' then
estado <= SUBE_GANCHO;
if t2 = '1' then trat <= '1'; end if; -- latch: el ciclo queda atado al T de P
end if;
when SUBE_GANCHO => -- la pieza sube antes de cualquier traslado
I <= '0'; D <= '0'; B <= '0'; V <= '0';
S <= '1'; seg <= PAT_P; -- conserva la ultima letra definida
if F = '1' then estado <= IDA_A_M; end if;
when IDA_A_M => -- carro a la derecha hasta la vertical del bano
I <= '0'; S <= '0'; B <= '0'; V <= '0';
D <= '1'; seg <= PAT_P;
if M = '1' then
if trat = '1' then estado <= BAJA_BANO; -- T latch: hay tratamiento
else estado <= IDA_A_N; -- T=0: se pasa de largo sin bajar
end if;
end if;
when BAJA_BANO => -- parado en M: el cilindro baja hasta E
I <= '0'; D <= '0'; S <= '0'; V <= '0';
B <= '1'; seg <= PAT_B; -- pantalla 'b': en la vertical del bano
if E = '1' then estado <= SUBE_BANO; end if;
when SUBE_BANO => -- retirada de la pieza del bano hasta F
I <= '0'; D <= '0'; B <= '0'; V <= '0';
S <= '1'; seg <= PAT_B;
if F = '1' then estado <= IDA_A_N; end if;
when IDA_A_N => -- derecha hasta el destino (gancho arriba)
I <= '0'; S <= '0'; B <= '0'; V <= '0';
D <= '1';
if trat = '1' then seg <= PAT_B; else seg <= PAT_P; end if;
if N = '1' then estado <= BAJA_DESTINO; end if;
when BAJA_DESTINO => -- parado en N: el cilindro baja hasta E
I <= '0'; D <= '0'; S <= '0'; V <= '0';
B <= '1'; seg <= PAT_D;
if E = '1' then estado <= DESTINO; end if;
when DESTINO => -- listo para desenganchar
I <= '0'; D <= '0'; S <= '0'; B <= '0';
V <= '1'; seg <= PAT_D; -- pantalla 'd'
if p2 = '1' and p3 = '0' then estado <= SUBE_RETORNO; end if;
when SUBE_RETORNO => -- gancho vacio sube a F antes de regresar
I <= '0'; D <= '0'; B <= '0'; V <= '0';
S <= '1'; seg <= PAT_D;
if F = '1' then estado <= RETORNO; end if;
when RETORNO => -- carro a la izquierda hasta L
D <= '0'; S <= '0'; B <= '0'; V <= '0';
I <= '1'; seg <= PAT_U; -- pantalla 'U': volviendo a la inicial
if L = '1' then estado <= BAJA_ORIGEN; end if;
when BAJA_ORIGEN => -- gancho vacio baja en L para el siguiente ciclo
D <= '0'; S <= '0'; I <= '0'; V <= '0';
B <= '1'; seg <= PAT_U;
if E = '1' then estado <= PARADO; trat <= '0'; end if;
when others =>
estado <= PARADO; trat <= '0';
I <= '0'; D <= '0'; S <= '0'; B <= '0'; V <= '0';
seg <= PAT_P;
end case;
end if;
end process;
end architecture ASM;
Notas para el examen: los nombres de los once estados VHDL son exactamente los rótulos de la
ASM; si escribes la ASM con menos bloques (por ejemplo fusionando BAJA_BANO+SUBE_BANO en un
bloque con cajas de condición), el VHDL debe seguir tu diagrama, no el de la guía. El latch
trat y los sincronizadores p1..p3/t1..t2 son los únicos registros «extra» además del
registro de estado: decláralos en la tarjeta identificativa del diagrama para que el VHDL no
salga de la nada. El enclavamiento de T no tiene referencia directa en los apuntes: es una
decisión de diseño amparada en el literal «previamente» y en registrar las entradas de puerto
(Tema 3 pág. 25).
Errores típicos — P1
- Responder a P por nivel (o no pensar en cuándo se suelta): con el dedo pegado, la ASM dispara la fase siguiente nada más llegar al estado de espera. El ejercicio es literal: dos pulsaciones por ciclo; si no detectas el frente, declara estados de espera de la suelta — pero no dejes el nivel pelado.
- Mover el carro con el gancho abajo (arrastre): salir de
PARADOhacia D sin pasar porSUBE_GANCHO, o iniciarRETORNOsinSUBE_RETORNO: la pieza (o el gancho) barre el borde del baño. Regla: SIEMPRE subir a F antes de I/D y bajar a E solo parado en una marca. - Re-bajar en M al volver de la inmersión si la salida de
SUBE_BANOreconectaIDA_A_M(que sigue viendo M=1): la grúa se queda sumiendo y resumiendo la pieza en bucle. La segunda pierna del trayecto esIDA_A_N. - Ignorar T, leerlo tarde o cambiar de idea a mitad de ciclo: sin latch, el veredicto depende de cuándo mires; el enunciado fija la decisión en el instante de pulsar P.
- Encender V durante el trayecto o con el gancho alto: la verde es seguridad del operario;
solo vale en
PARADOyDESTINO. - Poner un temporizador de tratamiento (2 segundos, un contador a 50 MHz…): el examen no da ninguna magnitud temporal; la sumersión dura lo que tarda el cilindro. Inventar tiempos aquí es el error espejo de la cinta de junio-2023 (allí el dato era la duración indeterminada del pulso; aquí es la ausencia total de tiempos).
- Tratar E, F, L, M, N como pulsos fugaces («no llego a verlos») y montarle detección de flanco o latch a cada sensor: son finales de carrera por nivel estable; el frente solo hace falta en P.
- 'b' sin tratamiento o 'P' parado mientras el carro anda sin haberlo definido: la pantalla es Moore por estado; declara la tabla de las cuatro letras y qué conserva cada bloque de traslado (decisión 6), y no escribas 'b' cuando trat=0.
- Estados llamados
E0–E10: el VHDL debe reutilizar los rótulos de la ASM; y el P2 de este examen referencia a este mismo proceso. - Olvidar una salida en alguna rama del
case: con el proceso único de clase las salidas son registros con memoria implícita — la salida olvidada conserva el valor del flanco anterior (un motor que no se apaga al cambiar de estado, una verde que se queda encendida). Contrasta cada rama con la caja de salidas de su bloque ASM, salida por salida.
Baremo real del problema
a) Diagrama ASM de funcionamiento = 2,5 puntos; b) módulo VHDL que represente ese diagrama = 1,5 puntos. Suma 4,0 p y cuadra con el enunciado: sin erratas.
Esquema-resumen de la metodología
- Seca el enunciado en dos columnas — fija: los 12 elementos con su semántica, las cuatro letras de pantalla, dos pulsaciones por ciclo, «previamente» para T, y el dibujo (posición inicial = L con gancho abajo). No fija: la tabla de segmentos, si el gancho baja en destino, dónde se lee T, ningún tiempo: cada uno es una decisión documentada.
- Clasifica cada entrada por su naturaleza — P = pulsación humana → frente; E/F/L/M/N = finales de carrera → nivel; T = interruptor del operario → nivel pero muestreado una vez por ciclo (latch). Este examen es el contrapunto de la cinta de junio-2023: allí el sensor era un pulso de duración indeterminada y aquí son todos niveles.
- Haz la ASM con la seguridad en la estructura — un bloque por fase del relato (subir→andar→bajar→subir→andar→bajar→verde→subir→volver→bajar), decisiones como niveles y vertical SIEMPRE arriba antes de horizontal. Los once estados no son un lujo: cada uno es una orden de actuador distinta.
- Codifica el visualizador como salida Moore — tabla a–g de las cuatro letras declarada arriba, con «el bloque conserva la última letra» en los traslados y 'b' condicionada al latch del tratamiento.
- Traduce a VHDL con la estructura de clase — proceso secuencial único con
wait until clk = '1'y reset síncrono; los sincronizadores antirrebote y el latch del tratamiento van dentro del mismo proceso; salidas dentro de la rama de cada estado ywhen others; nombres de estado = rótulos de la ASM. - Monta un modelo físico y un espejo — el TB simula el carro y el cilindro (sensores que valen 1 en su vertical) y coteja todas las salidas contra un segundo autómata escrito desde el enunciado; los bugs de arrastre, re-disparo y sumersión fantasma solo se ven si el entorno se mueve de verdad.
Idea transversal: el examen anterior (cinta, junio-2023) regalaba el dato «pulso de duración indeterminada» y premiaba mirar FRENTES; este no da ningún dato temporal y los sensores son topes de posición: aquí el truco se ha movido al pulsador P (humano, mantenido) y a la seguridad del proceso (nunca arrastrar, verde solo en parada). Cambia el sensor delicado, pero la lección es la misma: clasifica cada entrada antes de dibujar una sola caja.
Problema 2 — Control de la grúa del baño químico con microcontrolador picoBlaze (3,5 puntos)

Planteamiento. Es el mismo proceso del Problema 1 (grúa que traslada la pieza de Origen a Destino y, si el operario lo indica con T, la sumerge en el baño de la Solución), pero gobernado por un microcontrolador PicoBlaze (firmcore KCPSM3) en vez de una máquina de estados ASM/VHDL. El examen incorpora el bloque KCPSM3 impreso con sus pines y la tabla de instrucciones KCPSM3, que es la única ISA válida en este problema. El programa es una secuencia recta con sondeo de sensores: cada tramo del recorrido enciende su actuador por escritura de la máscara completa y espera el sensor correspondiente con lectura + prueba de bit.
Datos que fija el enunciado y decisiones de diseño
Fija el enunciado: los mismos elementos y la misma secuencia del Problema 1 (interruptor T, pulsador P, luz verde V, sensores L, M, N en el riel y E, F en el gancho, señales de tracción I/D y cilindro S/B, visualizador de 7 segmentos con las letras P, b, d, U); la figura del Problema 1 deja L bajo Origen, M bajo la Solución y N bajo Destino (son posiciones del proceso, no supuestos); el bloque KCPSM3 impreso con pines
IN_PORT[7:0],INTERRUPT,RESET,CLK,INSTRUCTION[17:0],OUT_PORT[7:0],PORT_ID[7:0],READ_STROBE,WRITE_STROBE,INTERRUPT_ACKyADDRESS[9:0]; la tabla de instrucciones impresa en el propio examen (retranscrita y verificada en la auditoría: incluye ADD/ADDC/SUB/SUBC, desplazamientos SL0-SLA/SR0-SRA, RL/RR, AND/OR/XOR, COMP/TEST,LOAD sX,sYyLOAD sX,kk,IN/OUTen formassX,(sY)ysX,kk,FETCH/STORE,JUMP/CALLcon condiciones(N)Zy(N)C,RET,RETI,EINTyDINT; no imprimeCONSTANTniRETURN— la constante vaLOAD sX,kky el retorno esRET). Baremo: a) 1 p + b) 2,5 p = 3,5 p.No lo fija el enunciado (supuestos de la guía, documentados):
- Anchura de la memoria de programa. El bloque impreso acaba en
ADDRESS[9:0]: 2¹⁰ = 1024 instrucciones de 18 bits es lo máximo direccionable. Declaro la memoria de programa como ROM externa de 1024 × 18 (bloque RAM de la FPGA conWEa 0; el tamaño exacto lo elige el diseñador).- Puertos y mapa de bits. Puerto de lectura H"00" (bit0 = T, bit1 = P, bit2 = L, bit3 = M, bit4 = N, bit5 = E, bit6 = F; bit7 libre) y puertos de escritura H"00" (bit0 = S, bit1 = B, bit2 = D, bit3 = I, bit4 = V; bits 5–7 libres) y H"01" (el patrón del visualizador de 7 segmentos). La E/S puede compartir número de puerto: se distingue por la strobe del ciclo.
- Codificación del visualizador. El examen no da la codificación de los segmentos. Declaro ánodo común (segmento encendido = 0) y patrón
{dp,g,f,e,d,c,b,a}— el mismo de los apuntes del tema: 'P' = H"88", 'b' = H"83", 'd' = H"91", 'U' = H"C1" (despiece en el apartado b). Con otra codificación el programa no cambia: solo cambian los cuatro valores.- Estado tras RESET. El programa arranca en el escenario normal del proceso: carro en L y gancho abajo (E) con la pieza lista para enganchar. Si el RESET cae en mitad de un ciclo, el programa vuelve a INICIO y retoma la secuencia completa desde el origen.
- Sondeo frente a interrupción. Los sensores se consultan por lectura (
IN+TEST+JUMP Z), sin usarINTERRUPT/INTERRUPT_ACKni el vector 3FFH: el baremo no pide interrupciones y el sondeo es el camino corto. La tabla imprimeEINT/DINT/RETI, pero este diseño no las necesita.- Frente del pulsador. Tras detectar P a 1 el programa espera a que vuelva a 0 (
JUMP NZen bucle): así un pulso largo o una manipulación lenta del operario no re-dispara la fase.- Pantalla durante el trayecto baño→destino. El enunciado define 'b' «durante el tiempo en que el sistema está en la vertical del baño» y 'd' al parar en destino: la guía mantiene 'b' escrita mientras el carro va de M a N y escribe 'd' al llegar.
Cálculos previos: las cuatro letras en hexadecimal
Patrón de 7 bits {dp,g,f,e,d,c,b,a}, ánodo común (0 = encendido), calculado a
mano y declarado en el recuadro (decisión 3):
- 'P' (parado inicial): encienden a, b, c, e, f, g →
1000 1000= H"88". - 'b' (tratamiento en la vertical del baño): encienden c, d, e, f, g →
1000 0011= H"83". - 'd' (parado en destino): encienden b, c, d, f, g →
1001 0001= H"91". - 'U' (volviendo a la posición inicial): encienden b, c, d, e, f →
1100 0001= **H"C1"".
El visualizador es el mismo hardware del proceso (el micro solo escribe su patrón; no hace falta decodificador en la FPGA).
a) Diagrama hardware y memoria de programa (1 punto)
![Bloque KCPSM3 impreso en el propio examen (imagen nativa del PDF): pines IN_PORT[7:0], INTERRUPT, RESET, CLK, INSTRUCTION[17:0], OUT_PORT[7:0], PORT_ID[7:0], READ_STROBE, WRITE_STROBE, INTERRUPT_ACK y ADDRESS[9:0].](assets/figs/figura-2-kcpsm3-nativa.jpg)
El diagrama se apoya en el bloque impreso en el examen (firmcore KCPSM3 con sus pines) y añade lo que el enunciado pide: conexiones detalladas, E/S y memoria de programa. Lo que se dibuja, paso a paso:
- Núcleo KCPSM3 embebido en la FPGA, con los pines del bloque impreso: por la
izquierda
IN_PORT[7:0],INTERRUPT,RESET,CLK,INSTRUCTION[17:0]; por la derechaOUT_PORT[7:0],PORT_ID[7:0],READ_STROBE,WRITE_STROBE,INTERRUPT_ACKyADDRESS[9:0].INTERRUPTeINTERRUPT_ACKquedan sin conectar (sondeo por lectura, decisión 5 del recuadro; el vector de interrupción 3FFH de la ROM queda sin usar). ElCLKva al núcleo; elRESETsincronizado inicializa el firmcore y, con el proceso ya en origen (decisión 4), el programa retoma desde INICIO. - Memoria de programa: ROM externa 1024 × 18.
ADDRESS[9:0]sale al bus de direcciones de la ROM (block RAM de la FPGA,WEa 0 para que parezca ROM) eINSTRUCTION[17:0]vuelve de ella. El programa del apartado b ocupa 73 posiciones de las 1024: sobra con holgura. - Entradas con lectura aislada por strobe. Las siete señales del operario y
de los sensores entran en el bus
IN_PORT[7:0]a través de lógica tri-state habilitada al compararPORT_ID = H"00"conREAD_STROBE(en el dibujo se agrupan en tres fuentes —operario, sensores del riel, sensores del gancho— y un multipuntaje resume la lógica: funcionalmente es equivalente). - Salidas con latch por
WRITE_STROBE. Dos latches: el del puerto H"00" (bits S, B, D, I, V — el latch mantiene el valor mientras el programa no lo cambie, y así el carro mantiene su sentido de marcha aunque el programa esté sondeando—) y el del puerto H"01" (7 patrones del visualizador, que también queda fijado). - El proceso de la figura cuelga del micro. Los actuadores (cilindro S/B,
tracción I/D, luz V) reciben del latch H"00"; los sensores E, F, L, M, N y las
entradas T y P del operario realimentan al bus
IN_PORT; el visualizador recibe el patrón del latch H"01".
📚 Teoría: Tema 4, pág. 11–12 del PDF «Tema 4 SD-II_20220512.pdf» — PicoBlaze: microcontrolador de 8 bits embebido en FPGA, características y diagrama de bloques. 📚 Teoría: Tema 4, pág. 31 y 33 del PDF «Tema 4 SD-II_20220512.pdf» — puertos de E/S: PORT_ID, strobes de lectura/escritura y conexión de múltiples fuentes a IN_PORT[7:0]. 📚 Teoría: Tema 4, pág. 34 y 45 del PDF «Tema 4 SD-II_20220512.pdf» — conexión de salidas a la lógica de la FPGA y almacenamiento del programa en bloque RAM 1K×18.
b) Programa en ensamblador comentado (2,5 puntos)

Convenciones de la tabla KCPSM3 impresa (las únicas que se usan):
- No hay
CONSTANT: la tabla solo imprimeLOAD sX,sYyLOAD sX,kk, así que todo valor inmediato entra porLOAD. Los puertos se definen conEQUyORG(directivas del ensamblador, no instrucciones). IN sX,kklee el puertokkyOUT sX,kkescribe en él el contenido desX; también existen las formas indirectasIN/OUT sX,(sY), que aquí no hacen falta.TEST sX,kkdeja Z=1 si el resultado del enmascaramiento vale 0 (el bit probado está a 0) y afecta a C; por eso toda espera esJUMP Z, buclemientras el sensor no llegue. La tabla escribe la condición como(N)Z: en el programa se usaJUMP Z, etiq(salta si Z=1) yJUMP NZ, etiq(salta si Z=0).- Saltos
JUMP etiqyJUMP (N)Z/(N)C, etiq; la tabla no imprime condicionesCC/CSniRETURN(el retorno esRET). No se usanFETCH/STORE(la scratchpad no interviene: el patrón del visualizador viaja en registros), niEINT/DINT/RETI(decisión 5), ni ninguna aritmética o de desplazamiento.
El programa (73 posiciones de la ROM; verificado con el mini-emulador documentado
en guias/NOTAS-elaboracion-junio-2022.md):
;=====================================================================
; Control del proceso de la grua (Junio-2022) con PicoBlaze KCPSM3
; Unico mnemonico valido: los de la tabla impresa en el examen.
; Aqui se usan LOAD, IN, OUT, TEST y JUMP (etiq, Z y NZ).
;
; Puerto de lectura H"00": bit0=T (interruptor) bit1=P (pulsador)
; bit2=L bit3=M bit4=N (riel) bit5=E bit6=F (gancho)
; Puerto de salida H"00": bit0=S (sube) bit1=B (baja) bit2=D (derch)
; bit3=I (izq) bit4=V (luz verde)
; Puerto de salida H"01": patron 7 segmentos {dp,g,f,e,d,c,b,a},
; 'P'=H"88" 'b'=H"83" 'd'=H"91" 'U'=H"C1"
;=====================================================================
P_ENT EQU H"00" ; puerto de lectura (decision propia)
P_SAL1 EQU H"00" ; puerto de las salidas del proceso
P_SEG EQU H"01" ; puerto del visualizador 7 segmentos
ORG H"000"
; ---------------------------------------------------------------------
; Arranque: deixo los 4 patrones del visualizador en registros y coloco
; el estado de parada inicial: verde V=1, pantalla 'P', actuadores 0.
; ---------------------------------------------------------------------
INICIO: LOAD s4, H"88" ; patron 'P' (parado en la posicion inicial)
LOAD s5, H"83" ; patron 'b' (vertical del bano)
LOAD s6, H"91" ; patron 'd' (parado en destino)
LOAD s7, H"C1" ; patron 'U' (volviendo a la inicial)
LOAD s2, H"10" ; s2 = mascara "V encendida, todo lo demas 0"
OUT s4, P_SEG ; pantalla 'P'
OUT s2, P_SAL1 ; V=1: el operario ya puede enganchar la pieza
; ---------------------------------------------------------------------
; Espera 1: sondear el pulsador P (bit1) y luego esperar su suelta.
; ---------------------------------------------------------------------
PULSO1: IN s1, P_ENT ; leo el estado del proceso
TEST s1, H"02" ; probamos bit1 (P): Z=1 mientras P este a 0
JUMP Z, PULSO1 ; espero el pulsador
SOLT1: IN s1, P_ENT ; P ya a 1: espero a que vuelva a 0
TEST s1, H"02" ; Z=0 mientras P se mantenga
JUMP NZ, SOLT1 ; suelta hecha (evita re-disparos)
; ---------------------------------------------------------------------
; Subida de la pieza enganchada: S=1 hasta que el gancho llegue arriba (F).
; ---------------------------------------------------------------------
SUBE1: LOAD s2, H"01" ; bit0=S (retira la verde: ya no se toca el gancho)
OUT s2, P_SAL1
ALTO1: IN s1, P_ENT ; sondeo el tope alto
TEST s1, H"40" ; probamos bit6 (F): Z=1 mientras F este a 0
JUMP Z, ALTO1 ; espero arriba
; ---------------------------------------------------------------------
; Carrera hacia la derecha: D=1 hasta el sensor M (vertical del bano).
; ---------------------------------------------------------------------
DERE1: LOAD s2, H"04" ; bit2=D (carro a la derecha)
OUT s2, P_SAL1
EN_M: IN s1, P_ENT ; sondeo el sensor M del riel
TEST s1, H"08" ; probamos bit3 (M): Z=1 mientras M este a 0
JUMP Z, EN_M ; espero la vertical del bano
; Parado en M: pantalla 'b' y decido con T si hay que sumergirse.
LOAD s2, H"00" ; mascara "todas las salidas apagadas"
OUT s2, P_SAL1 ; carro parado en la vertical del bano
OUT s5, P_SEG ; pantalla 'b' (tratamiento)
IN s1, P_ENT ; leo T ahora, en el punto de decision
TEST s1, H"01" ; probamos bit0 (T): Z=1 si T vale 0
JUMP Z, CONT_DER ; T=0: salto el sumergimiento
; T=1: inmersa (B=1 hasta E) y retirada del bano (S=1 hasta F).
BAJAR: LOAD s2, H"02" ; bit1=B (cilindro baja)
OUT s2, P_SAL1
ABAJO1: IN s1, P_ENT ; sondeo el tope bajo E (pieza sumergida)
TEST s1, H"20" ; probamos bit5 (E)
JUMP Z, ABAJO1 ; espero abajo en el bano
SUBE2: LOAD s2, H"01" ; S=1: sacamos la pieza del bano
OUT s2, P_SAL1
ALTO2: IN s1, P_ENT ; sondeo el tope alto de nuevo
TEST s1, H"40" ; bit6=F
JUMP Z, ALTO2 ; espero arriba
; ---------------------------------------------------------------------
; Retomo la derecha con D=1 hasta el sensor N (destino). Pantalla 'b'
; mientras dura el trayecto M->N (decision 7 del recuadro).
; ---------------------------------------------------------------------
CONT_DER:
LOAD s2, H"04" ; D=1 otra vez
OUT s2, P_SAL1
EN_N: IN s1, P_ENT ; sondeo el sensor N del riel
TEST s1, H"10" ; probamos bit4 (N)
JUMP Z, EN_N ; espero el destino
; Parado en destino: pantalla 'd' y verde V=1 para desenganchar.
LOAD s2, H"10" ; V=1, demas salidas 0
OUT s2, P_SAL1
OUT s6, P_SEG ; pantalla 'd'
; ---------------------------------------------------------------------
; Espera 2: el operario desengancha, pulsa P de nuevo (y suelta).
; ---------------------------------------------------------------------
PULSO2: IN s1, P_ENT ; sondeo el pulsador
TEST s1, H"02" ; bit1=P
JUMP Z, PULSO2 ; espero el segundo pulso
SOLT2: IN s1, P_ENT ; espero la suelta
TEST s1, H"02"
JUMP NZ, SOLT2
; ---------------------------------------------------------------------
; Retorno: subir el gancho vacio (S=1 hasta F), luego el carro a la
; izquierda con I=1 hasta L, y pantalla 'U' durante el regreso.
; ---------------------------------------------------------------------
SUBE3: LOAD s2, H"01" ; S=1 (gancho vacio)
OUT s2, P_SAL1
ALTO3: IN s1, P_ENT ; sondeo F
TEST s1, H"40"
JUMP Z, ALTO3 ; espero arriba
IZQUI: LOAD s2, H"08" ; bit3=I (carro a la izquierda; V queda 0)
OUT s2, P_SAL1
OUT s7, P_SEG ; pantalla 'U' (volviendo a la inicial)
EN_L: IN s1, P_ENT ; sondeo el sensor L del riel
TEST s1, H"04" ; probamos bit2 (L)
JUMP Z, EN_L ; espero el origen
; En origen: bajo el gancho vacio (B=1 hasta E) para dejarlo listo.
BAJA0: LOAD s2, H"02" ; B=1 (carro ya parado en L)
OUT s2, P_SAL1
ABAJO0: IN s1, P_ENT ; sondeo E
TEST s1, H"20"
JUMP Z, ABAJO0 ; espero abajo
; Parada inicial: pantalla 'P' y verde para enganchar la siguiente pieza.
FINCIC: LOAD s2, H"10" ; V=1, actuadores 0
OUT s2, P_SAL1
OUT s4, P_SEG ; pantalla 'P'
JUMP PULSO1 ; y vuelta a la espera 1
Justificaciones que el examinador pide explicar:
- La secuencia es la del Problema 1 en modo secuencia recta: INICIO → espera
del pulso P → subida (F) → carrera D (M) → [bajada B (E) + subida S (F)] si T=1
→ carrera D (N) → verde + espera del segundo P → subida (F) → retorno I (L) →
bajada B (E) → verde y vuelta a INICIO. Cada
OUTescribe la máscara completa del latch (H"10",H"01",H"04",H"00",H"02",H"08"): así ningún bit queda ambiguo y el latch mantiene la salida mientras el micro sondea. - El sensor se prueba con
IN+TEST+JUMP Z: mientras el bit no vale,TESTdeja Z=1 y el bucle sigue sondeando; en cuanto el carro pisa la marca, el bit pasa a 1, el enmascaramiento ya no da 0 y se cae del bucle. La espera está escrita al revés de lo que parece:JUMP Z, buclemientras no llegue. - El veredicto de T se lee en el punto de decisión (
IN+TESTen M) y no al principio del ciclo: si el operario cambia T sobre la marcha, la decisión vale la del momento de la vertical. Con T=0 elJUMP Z, CONT_DERse salta la inmersión entera. - La luz verde V solo vale en los dos estados manipulables (parada inicial
con gancho abajo en L y parada en destino): al arrancar la subida se retira
(
H"01"retira el bit4) y vuelve conH"10"al llegar a N y al cerrar el ciclo. - El visualizador no es una salida "en el aire": el patrón se escribe por el
puerto H"01" y el latch lo mantiene; los cuatro códigos viajan en s4–s7,
cargados una sola vez al principio. Alternativa válida: guardarlos en la
scratchpad y
FETCH+OUT(el ejemplo del tema usa la RAM interna justo para eso); la guía lo omite por ahorrar instrucciones. - Nada de retardos de software ni de interrupciones: los tiempos del proceso los dan los sensores de final de carrera; los únicos tiempos que habría que temporizar en software no aparecen en este enunciado.
Trazada de verificación (mini-emulador del subconjunto KCPSM3 + entorno con el
proceso modelado: el efecto de cada actuador se aplica en las lecturas IN, el
operario pulsa al ver la pantalla 'P' con verde o 'd'; en la nota de elaboración):
Escenario T=1 (sumergimiento), mascaras del latch H"00" por orden:
H"10" verde+P → H"01" sube → H"04" derecha → H"00" para en M → H"02" baja al
bano → H"01" sube → H"04" derecha → H"10" para en N con verde → H"01" sube →
H"08" izquierda → H"02" baja en origen → H"10" verde+P (y dos ciclos
completos mas, sin derivas).
Escenario T=0: identico sin la pareja H"02"/H"01" del bano.
Pantallas por orden: 88 'P' → 83 'b' → 91 'd' → C1 'U' → 88 'P' (dos veces mas).
Asserts de la trazada: orden exacto de máscaras y de patrones 7 segmentos en los
dos escenarios T=0 y T=1; dos ciclos completos sin derivas; invariantes de
seguridad — el carro nunca recibe orden de marcha con el gancho abajo, no hay
orden vertical y horizontal a la vez, la bajada al baño ocurre solo en M y la
pantalla 'b' se escribe con el carro en la vertical — y cota de instrucciones que
descarta cualquier bucle infinito del programa. Un alijo de 6 errores inyectados
al ensamblador (condiciones JUMP invertidas, patrón equivocado, sensor
incorrecto, salto de sumergimiento eliminado…) hace saltar todos los asserts: el
harness no es decorativo. TRAZADA OK.
📚 Teoría: Tema 4, pág. 27–28 del PDF «Tema 4 SD-II_20220512.pdf» — flags ZERO y CARRY en las instrucciones TEST y COMP. 📚 Teoría: Tema 4, pág. 30 del PDF «Tema 4 SD-II_20220512.pdf» — control del flujo: JUMP condicionado a los flags ZERO/CARRY. 📚 Teoría: Tema 4, pág. 37 del PDF «Tema 4 SD-II_20220512.pdf» — EINT/DINT, vector 3FFH y RETI (vía de interrupción descartada en este diseño). 📚 Teoría: Tema 4, pág. 41 del PDF «Tema 4 SD-II_20220512.pdf» — alternativa con la scratchpad RAM como tabla de patrones para el visualizador de 7 segmentos.
Errores típicos — P2
- Usar mnemónicos que no están en la tabla impresa del examen. Manda la tabla
del papel: ahí no hay
CONSTANT(la constante entra conLOAD sX,kk), el retorno esRET(noRETURN) y la E/S esIN/OUT, noINPUT/OUTPUT. Los saltos sonJUMP etiq,JUMP (N)Z, etiqyJUMP (N)C, etiq— nada deCC/CS. - Omitir la memoria de programa en el diagrama. El apartado a) la pide
expresamente:
ADDRESS[9:0](10 bits = 1024 posiciones de 18 bits) sale a la ROM eINSTRUCTION[17:0]vuelve al firmcore. Dibujar solo el micro con sus pines se queda corto. - Invertir la condición de
TEST. ConTEST s1,H"40",Z=1significa que el bit probado no está: la espera esJUMP Z, espera. Al revés, la fase entera se dispara antes de tiempo. - Pegar la pantalla y la verde sin apagar los actuadores. Cada
OUTdebe escribir la máscara completa: si el latch conservara una D=1 anterior, el carro seguiría moviéndose durante la inmersión. En la guía elH"00"de parada antes de la bajada al baño es obligatorio. - Olvidar la suelta del pulsador. Un pulso de P mantenido hace que la fase
siguiente arranque con el operario todavía tocando; el par
PULSO/SOLT(JUMP NZen bucle) lo limpia. - No declarar puertos, mapa de bits y codificación del visualizador. Sin
EQU+ comentario bit a bit y sin los cuatro patrones declarados, el examinador no puede seguir el programa. Declara la codificación (ánodo común o cátodo) y justifica los H"88"/H"83"/H"91"/H"C1". - No marcar
INTERRUPT/INTERRUPT_ACKcomo sin conectar. Si no usas el vector 3FFH, el pin debe aparecer tachado o sin conectar en el diagrama. - Encender la verde durante los movimientos. V solo vale en parada inicial y en destino: dar seguridad durante la marcha es un error de proceso, no de ensamblador.
- Sumergir la pieza en otra posición (o sin comprobar T en el punto de decisión): la lectura de T debe hacerse al llegar a M, no al principio del ciclo.
Baremo real del problema
a) Diagrama hardware (conexiones, E/S y memoria de programa) = 1 punto; b) programa en ensamblador comentado = 2,5 puntos. Suma 3,5 p y cuadra con el enunciado: sin erratas.
Esquema-resumen de la metodología
- Leer el bloque y la tabla impresos — el examen da el firmcore con sus pines y su tabla KCPSM3 (exclusiva del examen: retranscribirla siempre; el conjunto de mnemónicos cambia entre exámenes). El diagrama se dibuja alrededor de esos pines y el ensamblador solo puede usar mnemónicos de la tabla.
- Fijar el mapa de E/S antes de programar —
EQUde puertos y mapa de bits comentado: entradas del operario/sensores por un puerto, salidas de proceso por otro y el visualizador por un tercero. - Traducir el proceso a secuencia recta — cada tramo del grafo del
Problema 1 es un bloque
OUT(máscara completa) + bucleIN+TEST+JUMP Zhasta el sensor de final de carrera. Las bifurcaciones del ASM (T=0/T=1) son unTEST+JUMPen el punto de decisión. - Gestionar la interfaz humana — luz verde en los estados manipulables y espera de suelta del pulsador, para no re-disparar fases.
- Salidas que no se auto-explican: declararlas — los cuatro patrones del
visualizador se calculan a mano contra la codificación declarada y se cargan
en registros para poder escribirlos por
OUT. - Verificar con emulador — el mini-emulador de la ISA impresa comprueba el orden de fases, los dos escenarios de T, la seguridad del proceso y la ausencia de bucles infinitos antes de entregar la solución.
Idea transversal: un microcontrolador no sustituye al ASM — lo traduce. Cada
caja del diagrama del Problema 1 pasa a ser un bloque recto de OUT + sondeo; la
RAM de programa es barata (73 de 1024 posiciones caben de sobra), y el trabajo
duro del ejercicio está en el mapa de bits y en respetar la tabla impresa, no en
la aritmética, que aquí apenas aparece.
Problema 3 — Mapa de memoria de 1M posiciones (2,5 puntos)

Planteamiento. La CPU tiene bus de datos de 16 bits y bus de direcciones de 20 bits → 2²⁰ = 1 048 576 posiciones de 16 bits (1M), mapa 00000H–FFFFFH, líneas A19–A0. Hay que colocar 512 K posiciones de RAM (las más bajas), 256 K de ROM justo detrás y un módulo E/S de 16 posiciones con CS a nivel ALTO a continuación de la ROM, con el menor número de CIs de los de la tabla: ROM (64K×8, 128K×1, 128K×8, CS ALTA) y RAM (128K×1, 256K×8, 16K×4, CS BAJA). Cada bloque se monta con expansión de palabras y de bits, y la decodificación se hace con las líneas altas respetando la polaridad CS de cada tipo (RAM BAJO; ROM y E/S ALTO).
Datos que fija el enunciado y decisiones de diseño. Fija el enunciado: el bus de datos de 16 bits y el de direcciones de 20 bits (→ mapa 00000H–FFFFFH con 5 dígitos hex, A19…A0); los tamaños 512 K RAM, 256 K ROM, E/S de 16 posiciones con CS ALTO; que la RAM va en las posiciones más bajas; los CIs disponibles (ROM 64K×8, 128K×1, 128K×8 con CS ALTA; RAM 128K×1, 256K×8, 16K×4 con CS BAJA); y el baremo a) 0,5 · b) 0,5 · c) 1,0 · d) 0,5 (suma 2,5, cuadra con el enunciado). No lo fija el enunciado: el orden exacto de ROM y E/S respecto a la RAM (frase «justo antes» ambigua: supuesto 1 declarado arriba, orden RAM→ROM→E/S creciente), la colocación fina del E/S (supuesto 2: pegado tras la ROM en C0000H) y la estructura del decodificador (supuesto 3: ecuaciones con A19–A4; también vale un 3–8 MSI + puertas). La división interna de cada bloque en dos grupos (RAM-A/RAM-B y ROM-A/ROM-B) es decisión propia: viene impuesta por los CIs disponibles (no existe CI RAM de 512 K ni CI ROM de 256 K), y se justifica en el apartado a).
Datos de partida y cálculos de cabida
- Espacio: 20 líneas de dirección → 2²⁰ = 1 048 576 posiciones = 100000H posiciones → mapa 00000H–FFFFFH (5 dígitos hex = 20 bits exactos).
- Ancho de palabra: 16 bits (bus de datos) → cada CI de 8 bits aporta solo la mitad.
- Tamaños en hex: 512 K = 80000H; 256 K = 40000H; 128 K = 20000H; 16 = 10H.
- Colocación (supuestos 1–2): RAM en 00000H–7FFFFH (512 K), ROM justo detrás en 80000H–BFFFFH (256 K), E/S justo detrás en C0000H–C000FH (16).
- Adyacencia exacta y sin solapes: 7FFFFH+1 = 80000H y BFFFFH+1 = C0000H.
- Suma usada: 524 288 + 262 144 + 16 = 786 448 ≤ 1 048 576 ✔; queda libre C0010H–FFFFFH = 262 128 posiciones (comprobado barriendo el espacio completo, ver apartado d).
a) Módulos de memoria necesarios y mapa de memoria (0,5 p)

Nº mínimo de CI por bloque (expansión de palabras × expansión de bits, con el bus de datos de 16 bits la expansión de bits 8→16 obliga a 2 CI en paralelo siempre):
| Bloque | Tamaño | CI elegido | Palabras | Bits | Nº CI |
|---|---|---|---|---|---|
| RAM | 512K×16 | RAM 256K×8 | 512K/256K = 2 grupos | 16/8 = 2 | 4 (2 grupos × 2 en paralelo) |
| ROM | 256K×16 | ROM 128K×8 | 256K/128K = 2 grupos | 16/8 = 2 | 4 (2 grupos × 2 en paralelo) |
| E/S | 16 pos | módulo E/S hecho (no se construye con CIs de memoria) | — | — | 1 módulo |
Total: 8 CIs de memoria (4 RAM + 4 ROM) + el módulo E/S + la lógica de decodificación.
Trampa didáctica de la tabla — los otros CIs disponibles son todos peores, verifícalo en el examen para justificar la elección:
| CI | RAM 512K×16 con él | ROM 256K×16 con él |
|---|---|---|
| RAM 256K×8 / ROM 128K×8 | 4 ✔ | 4 ✔ |
| ROM 64K×8 | — | 8 (4 grupos × 2) |
| ROM 128K×1 / RAM 128K×1 | 64 (4 grupos × 16 en paralelo) | 32 |
| RAM 16K×4 | 128 (32 grupos × 4) | — |
Las divisiones en dos grupos son consecuencia de los CIs: la RAM de 512 K se parte en RAM-A (00000H–3FFFFH) y RAM-B (40000H–7FFFFH), cada una 256K×16 con 2 CI 256K×8 en paralelo; la ROM de 256 K se parte en ROM-A (80000H–9FFFFH) y ROM-B (A0000H–BFFFFH), cada una 128K×16 con 2 CI 128K×8 en paralelo. Todos los bloques quedan alineados a potencias de 2, lo que deja la decodificación limpia (apartado b).
Mapa del sistema (dibujo en el apartado; el SVG validado va en la figura siguiente):
00000H ┌────────────────────────────────┐
│ RAM-A 256K×16 (2 CI 256K×8) │ CS BAJA
3FFFFH ├────────────────────────────────┤
│ RAM-B 256K×16 (2 CI 256K×8) │ CS BAJA
40000H │ │
│ (RAM total 512K, las
│ posiciones más bajas)
7FFFFH ├────────────────────────────────┤
│ ROM-A 128K×16 (2 CI 128K×8) │ CS ALTA
9FFFFH ├────────────────────────────────┤
│ ROM-B 128K×16 (2 CI 128K×8) │ CS ALTA
A0000H │ │
BFFFFH ├────────────────────────────────┤
│ E/S 16 posiciones │ CS ALTA
C000FH ├────────────────────────────────┤
│ Libre 262.128 (sin decodificar)│
FFFFFH └────────────────────────────────┘
El mapa dibujado (los rangos y los CIs de cada grupo son los calculados arriba):
Figura: mapa de memoria del sistema (apartado a): los seis bloques en orden, con direcciones de inicio, tamaños, nº de posiciones y CIs de cada grupo.
📚 Teoría: Tema 5, págs. 32–33 del PDF «Tema 5 SD-II_20230215.pdf» — mapa de memoria: concepto y ejemplo con E/S. 📚 Teoría: Tema 1, pág. 53 del PDF «Tema 1 SD-II_20200206.pdf» — memorias organizadas en palabras de m bits.
b) Tabla de direcciones (binario y hexadecimal) y decodificación (0,5 p)
Binario: las 20 líneas A19…A0, agrupadas de 4 en 4 (cada grupo = un dígito hex).
| Bloque | Inicial (binario A19…A0) | Final (binario A19…A0) | Inicial hex | Final hex | Posiciones | Decodificación (señal CS) |
|---|---|---|---|---|---|---|
| RAM-A | 0000 0000 0000 0000 0000 |
0011 1111 1111 1111 1111 |
00000H | 3FFFFH | 262 144 | CS̄_A = A19 + A18 (BAJO) |
| RAM-B | 0100 0000 0000 0000 0000 |
0111 1111 1111 1111 1111 |
40000H | 7FFFFH | 262 144 | CS̄_B = A19 + NOT(A18) (BAJO) |
| ROM-A | 1000 0000 0000 0000 0000 |
1001 1111 1111 1111 1111 |
80000H | 9FFFFH | 131 072 | CS_A = A19·NOT(A18)·NOT(A17) (ALTO) |
| ROM-B | 1010 0000 0000 0000 0000 |
1011 1111 1111 1111 1111 |
A0000H | BFFFFH | 131 072 | CS_B = A19·NOT(A18)·A17 (ALTO) |
| E/S | 1100 0000 0000 0000 0000 |
1100 0000 0000 0000 1111 |
C0000H | C000FH | 16 | CS_ES = A19·A18·NOT(A17+…+A4) (ALTO) |
| Libre | 1100 0000 0000 0001 0000 |
1111 1111 1111 1111 1111 |
C0010H | FFFFFH | 262 128 | no se decodifica (ninguna CS activa) |
Cómo se deducen las ecuaciones. Un bloque de 2ⁿ consume internamente sus n líneas bajas; la CS se fabrica con las que quedan por encima:
- RAM-A: 256 K = 2¹⁸ → internas A17–A0 → CS̄ con A19, A18. Quiero CS̄ = 0 solo con
A19=0 y A18=0 →
CS̄_A = A19 + A18(un NOR). - RAM-B: internas A17–A0 → CS̄ con A19, A18. Quiero CS̄ = 0 solo con A19=0 y
A18=1 →
CS̄_B = A19 + NOT(A18): la única suma que da 0 exactamente en ese caso. ⚠ Ojo con el doble negado: la sumaA19 + NOT(A18)ya es la señal activa a nivel BAJO (no se le añade unNOTexterior: negarla seleccionaría toda la mitad alta del mapa). Y el productoA19·NOT(A18)tampoco sirve como CS̄: valdría 0 (activo) en todas las direcciones salvo la zona ROM. - ROM-A: 128 K = 2¹⁷ → internas A16–A0 → CS con A19, A18, A17 = 100 → producto
directo
A19·NOT(A18)·NOT(A17). ROM-B = 101 →A19·NOT(A18)·A17. - E/S: 16 = 2⁴ → internas A3–A0 → hay que exigir A17…A4 todas a 0:
CS_ES = A19·A18·NOT(A17+A16+…+A4)(burbuja en la OR de 14 entradas). - Nota didáctica: el bloque RAM completo (512 K) se habilita «gratis» con A19 directo a CS̄ (A19=0 ⟺ posiciones más bajas — encaja literalmente con el enunciado); luego A18 subdivide el bloque en RAM-A y RAM-B. En el examen basta con dar las dos CS̄ por grupo, pero mencionar esta estructura de dos niveles justifica por qué los grupos son 256 K y no otro reparto.
Nivel CI (qué selecciona cada integrado): los dos CI de un mismo grupo comparten direcciones y CS — uno conduce D7–D0 y el otro D15–D8; las direcciones internas son A17–A0 en los CI RAM de 256K y A16–A0 en los CI ROM de 128K; el módulo E/S usa A3–A0.
| CI / módulo | Direcciones que ocupa | Direcciones internas | CS |
|---|---|---|---|
| RAM-A0 (D7–D0) + RAM-A1 (D15–D8) | 00000H–3FFFFH | A17–A0 | CS̄_A común |
| RAM-B0 (D7–D0) + RAM-B1 (D15–D8) | 40000H–7FFFFH | A17–A0 | CS̄_B común |
| ROM-A0 (D7–D0) + ROM-A1 (D15–D8) | 80000H–9FFFFH | A16–A0 | CS_A común |
| ROM-B0 (D7–D0) + ROM-B1 (D15–D8) | A0000H–BFFFFH | A16–A0 | CS_B común |
| Módulo E/S | C0000H–C000FH | A3–A0 | CS_ES (ALTO) |
Comprobación por conteo: 262 144 + 262 144 + 131 072 + 131 072 + 16 = 786 448 posiciones seleccionadas, 262 128 sin seleccionar, total 1 048 576 — sin solapes (verificado dirección a dirección en el apartado d).
📚 Teoría: Tema 5, págs. 34–35 del PDF «Tema 5 SD-II_20230215.pdf» — condiciones de habilitación con líneas altas.
c) Diagrama lógico completo del sistema (1 p)
Dibujar (el SVG validado va pegado en la versión final; mientras, esta es la descripción con la que se dibuja a mano en el examen):
- CPU (bloque): direcciones A19…A0 (20 líneas), datos D15…D0 (bidireccional), control R/W̄.
- Bloque de decodificación con las ecuaciones del apartado b): cinco salidas
CS̄_A = A19+A18yCS̄_B = A19+NOT(A18)(dos OR: su salida ya vale 0 solo dentro del rango RAM; la entrada CS̄ del CI se dibuja con burbuja = BAJO) yCS_A,CS_B,CS_ES(tres AND, ALTO). Entradas: A19, A18, A17 y (para E/S) A16…A4; las entradas A18 de RAM-B/ROM y la suma A17+…+A4 del E/S entran negadas (burbuja). - RAM-A (00000H–3FFFFH): 2 CI 256K×8 en paralelo → D7–D0 y D15–D8; A17–A0 a
ambas; CS̄ común =
CS̄_A; R/W̄ → WE/OE. RAM-B igual conCS̄_B. - ROM-A (80000H–9FFFFH): 2 CI 128K×8 en paralelo → D7–D0 y D15–D8; A16–A0 a
ambas; CS común =
CS_A(ALTO, sin burbuja). ROM-B igual conCS_B. - Módulo E/S (C0000H–C000FH): A3–A0, D15–D0, CS =
CS_ES(ALTO) y las señales de lectura/escritura del bus de control. - Deja claro qué líneas van a cada sitio: A19/A18 a las CS de RAM; A19/A18/A17 a las de ROM; A19/A18 y A17–A4 a la del E/S; A17–A0 y A16–A0 a las direcciones internas; A3–A0 al E/S. En la zona libre C0010H–FFFFFH ninguna CS se activa.
El diagrama montado (es la descripción anterior dibujada — cinco puertas para las CS y los CIs en paralelo por grupo):
Figura: diagrama lógico completo — CPU, cinco puertas que generan CS̄_A/CS̄_B (OR con burbuja en la entrada del grupo RAM: nivel BAJO), CS_A/CS_B/CS_ES (AND; el E/S con burbuja en la entrada NOT(A17+…+A4)) y los grupos con sus 2 CIs en paralelo (D7–D0 y D15–D8).
📚 Teoría: Tema 5, pág. 40 del PDF «Tema 5 SD-II_20230215.pdf» — habilitaciones CE/EN de cada integrado.
d) Módulo VHDL del decodificador del mapa (FPGA) (0,5 p)
El apartado d) pide sustituir el circuito de decodificación por un módulo VHDL (síntesis en FPGA). Entradas: las líneas altas del bus (A19…A4 es suficiente, pero se toma el bus completo A19–A0 por comodidad y para poder barrerlo entero). Salidas: las 5 CS con sus polaridades —RAM a nivel BAJO, ROM y E/S a nivel ALTO.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity dec_mapa is
port (
A : in std_logic_vector(19 downto 0); -- bus de direcciones
CS_RAM_A : out std_logic; -- 00000H-3FFFFH, BAJA
CS_RAM_B : out std_logic; -- 40000H-7FFFFH, BAJA
CS_ROM_A : out std_logic; -- 80000H-9FFFFH, ALTA
CS_ROM_B : out std_logic; -- A0000H-BFFFFH, ALTA
CS_ES : out std_logic -- C0000H-C000FH, ALTA
);
end entity dec_mapa;
architecture Behaviour of dec_mapa is
begin
-- RAM (CS BAJA): OR directa; la suma ya vale 0 solo dentro de su rango
CS_RAM_A <= A(19) or A(18); -- 00000H-3FFFFH
CS_RAM_B <= A(19) or not A(18); -- 40000H-7FFFFH
-- ROM (CS ALTA): producto directo
CS_ROM_A <= A(19) and not A(18) and not A(17); -- 80000H-9FFFFH
CS_ROM_B <= A(19) and not A(18) and A(17); -- A0000H-BFFFFH
-- E/S (CS ALTA): A19=1, A18=1 y A17..A4 todas 0
CS_ES <= A(19) and A(18) and not (
A(17) or A(16) or A(15) or A(14) or A(13) or A(12) or A(11) or
A(10) or A( 9) or A( 8) or A( 7) or A( 6) or A( 5) or A( 4)); -- C0000H-C000FH
end architecture Behaviour;
Verificación realizada (GHDL 4.1.0 + modelo Python propio). El módulo se analizó
con ghdl --std=08 sin errores y se simuló con un testbench segmental (79
comprobaciones: entorno de las 7 fronteras del mapa —00000H, 40000H, 80000H,
A0000H, C0000H, C0010H, FFFFFH— y centros de bloque, comparando cada salida con la
expectativa calculada por rangos): 79 checks, 0 fallos. Como el simulador GHDL no
es práctico para el millón de direcciones, el barrido completo de las 2²⁰
direcciones se hizo en Python con las ecuaciones de arriba: RAM-A 262 144 + RAM-B
262 144 + ROM-A 131 072 + ROM-B 131 072 + E/S 16 = 786 448 habilitadas, zona libre
262 128, solapes = 0, total 1 048 576. (De hecho el TB detectó un not(...) de
más en la primera versión del VHDL: sin él, la OR ya es activa a nivel BAJO.
Guárdate la lección: la doble negación de una CS̄ es el fallo que los barridos
cazan y el examen penaliza.) Scripts: dec_mapa.vhdl, tb_dec_mapa.vhdl,
barrido.py en ~/.hermes/cache/scratch/jun22p3/.
📚 Teoría: Tema 5, págs. 36–37 del PDF «Tema 5 SD-II_20230215.pdf» — decodificación del mapa en VHDL, dos versiones. 📚 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 — P3
- Polaridad de RAM mal orientada:
CS̄_B = A19 + NOT(A18)es una OR sin negar (la suma ya vale 0 solo en 40000H–7FFFFH). Dos errores simétricos: añadir unNOTexterior (NOR) o escribir el productoA19·NOT(A18)— ambos habilitan la RAM-B fuera de su rango (casi todo el mapa). En VHDL, elnot(...)de más es facilísimo: el testbench de rangos lo detecta en cuanto lo corras. - Olvidar la expansión de bits: bus de datos de 16 y CI de 8 → 2 CI en paralelo en cada grupo (4 CIs por bloque, no 2). Es lo primero que se comprueba.
- Caer en la trampa de la tabla: RAM 128K×1 obligaría a 64 CIs (y 16K×4 a 128) y ROM 64K×8 a 8 CIs; el menor número de CI exige RAM 256K×8 y ROM 128K×8. Justifica la elección con estas cuentas, no «porque me parece».
- Construir el E/S con CIs de memoria: el E/S es un módulo de 16 posiciones con CS ALTO; no se monta con RAM/ROM.
- Escribir direcciones con 4 dígitos hex: 20 bits = 5 dígitos (00000H–FFFFFH). Con 4 dígitos (0000H–FFFFH) estarías en un mapa de 16 bits.
- Olvidar A3–A0 internas del E/S: su CS debe exigir A17…A4 = 0; si solo usas A19·A18, el E/S cubriría 512 K posiciones y solaparía todo C0000H–FFFFFH.
- Contar mal la zona libre: C0010H–FFFFFH son 262 128 posiciones (1 048 576 − 786 448), no 262 144; 262 144 sería si el E/S no existiera.
- No declarar el supuesto del orden («justo antes»): el enunciado es ambiguo y la lectura literal auto-contradictoria; escribe en el examen cómo lo interpretas y por qué (supuesto 1), y sitúa el E/S pegado tras la ROM (supuesto 2).
- Decodificar la zona libre: no se hace ninguna CS para C0010H–FFFFFH; simplemente ninguna señal se activa ahí.
Baremo real del problema
a) 0,5 + b) 0,5 + c) 1,0 + d) 0,5 = 2,5 — cuadra exactamente con los 2,5 puntos que titula el enunciado (sin erratas en este examen).
Esquema-resumen de la metodología
- Derivar el espacio de la CPU — 20 bits de dirección → 2²⁰ = 1 048 576 posiciones 00000H–FFFFFH (5 dígitos hex, no 4) y 16 líneas de datos; comprobar cabida: 512 K + 256 K + 16 = 786 448 ≤ 1 048 576.
- Fijar el orden con supuestos declarados — «justo antes» es ambiguo: declarar la lectura RAM → ROM → E/S en direcciones crecientes (precedente «detrás/después/al final» en jul23/jul24/jun26) y pegar cada bloque al anterior: inicio = fin previo + 1 (RAM 00000H–7FFFFH, ROM 80000H–BFFFFH, E/S C0000H–C000FH, libre C0010H–FFFFFH).
- Elegir los CIs y justificar la cuenta — dentro de cada bloque, el CI de mayor capacidad de la tabla: RAM 256K×8 → 4 CIs y ROM 128K×8 → 4; descartar numéricamente las trampas (128K×1 → 64, 16K×4 → 128, 64K×8 → 8); el E/S es un módulo, no se monta con CIs de memoria.
- Repartir direcciones internas y escribir CS «limpias» — internas por tamaño (256K → A17–A0, 128K → A16–A0, 16 → A3–A0) y decodificar con A19–A4: para CS BAJA una OR sin negar (CS̄ = 0 solo en el rango: A19+A18 y A19+NOT(A18)); para CS ALTA el producto AND (ROM-A/B y E/S con NOT(A17+…+A4)).
- Dibujar, sintetizar y barrer — diagrama con las cinco puertas, burbujas solo donde toca y 2 CIs en paralelo por grupo; VHDL con LAS MISMAS ecuaciones (sin un
not(...)de más: la doble negación de una CS̄ es el error clásico); analizar en el simulador con un TB segmental de las fronteras y, si el simulador no da para el millón de direcciones, barrido exhaustivo equivalente en Python: conteos por bloque, solapes = 0, total = 1 048 576.