Guía de resolución — Examen de Sistemas Digitales II, Septiembre 2022 (9/9/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 | 3,5 (ASM 2 + VHDL 1,5) | Control de proceso de mezcla de producto y agua: válvula V2 (agua, 10 s), válvula V1 (producto hasta peso P), compuerta con motor C (5 s), motor M (10 s); reloj 10 MHz |
| 2 | 3,5 (hardware 1 + ensamblador 2,5) | El mismo proceso con microcontrolador picoBlaze (reloj 50 MHz y contadores externos C10s y C5s con CLK, Reset, INICIO_CUENTA y Fin_de_cuenta_10s/5s; el examen incorpora la tabla de instrucciones y el bloque KCPSM3) |
| 3 | 3,0 | Mapa de memoria de CPU de 8 bits de datos y 16 de direcciones, más ampliación de 8 KB de ROM |
Estado de esta guía: 3 de 3 problemas publicados (resueltos y verificados). El Problema 1 (ASM + VHDL del proceso de mezcla) está reescrito al estilo VHDL de clase (proceso único con
wait until, reset síncrono obligatorio) y verificado con GHDL--std=08 -fsynopsysen dos escalas de pre-escala con duraciones exactas contadas en flancos.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
- Lectura de la figura (datos del subsistema, partes a–d). El único enunciado gráfico del subsistema es la figura incrustada en el PDF, verificada pin por pin en dos pasadas de zoom sobre la imagen nativa y crops a 300 dpi: decodificador DEC 2–4 con select pin «1» = A15 y pin «0» = A14 (salidas Y0…Y3 activas a nivel ALTO); Y0 e Y1 pasan por una OR a la CS de M1; Y2 entra en una AND cuya otra entrada es A13 con barra — NOT(A13) — y su salida es la CS de M2; Y3 queda suelta, sin conectar; las CS de M1 y M2 están dibujadas sin burbuja (activas a nivel ALTO, coherente con la CS ALTA de la ROM pedida); la línea R/W̄ es global y va a ambos módulos. Adoptar la barra de A13 tal como está dibujada es clave: sin ella el mapa entero cambiaría (ver «Errores típicos»).
- Capacidad de los módulos de la figura. La figura no rotula la capacidad de M1 y M2; sale de sus pines de dirección: M1 recibe el bus A14–A0 (anotación /15) → 2¹⁵ = 32 K×8; M2 recibe A12–A0 (anotación /13) → 2¹³ = 8 K×8. El contraste con las CS del decodificador es exacto (cada módulo ocupa justo su rango, sin aliasing), lo que confirma la lectura de la figura.
- Estructura de la decodificación de la ROM (parte d). El enunciado no impone circuitos: la guía reutiliza la salida libre Y3 y la gating ·A13 como enable común de un segundo DEC 2–4 sobre A12 y A11 (equivalente funcional a 4 AND de 4 entradas). Cualquiera de las dos vale.
- Reparto de nibble en los chips en paralelo (parte b–d). Con 2 chips 2K×4 por banco, la guía asigna el chip «alto» a D7–D4 y el «bajo» a D3–D0; el examen no fija cuál de los dos va a cada nibble — es decisión propia, solo hay que ser coherente en el diagrama.
- Alcance del VHDL (parte e). El módulo debe cubrir el mapa nuevo completo: CS de M1, CS de M2 y las 4 CS de los bancos ROM (salidas todas a nivel ALTO). Los huecos A000H–BFFFH y C000H–DFFFH no generan ninguna señal: ahí ninguna CS debe activarse.
No son supuestos —los fija el examen y hay que respetarlos sí o sí: CPU con bus de datos de 8 bits y de direcciones de 16 bits; el subsistema de la figura tal como está dibujado; añadir 8 KB de ROM que terminen en 0xFFFF con chips 2K×4 y CS activa a nivel alto; baremo 0,5 + 0,75 + 0,25 + 1,0 + 0,5 = 3,0.
Problema 1 — Proceso de mezcla: ASM + VHDL (3,5 puntos)

Enunciado (literal de la hoja del examen). «1. (3,5 puntos). Se pretende realizar una mezcla de un determinado producto y agua. El proceso de mezcla se inicia al pulsar A (A es un PULSADOR) y se realiza de la siguiente forma: - Se permite salir agua a través de la válvula V2 durante un tiempo T1 = 10 s. - A continuación, el producto es vertido sobre un depósito intermedio mediante una válvula V1 hasta que alcanza un peso P. - Luego, el producto pesado se echa en el depósito de mezcla a través de una compuerta activada por el motor C. El tiempo de descarga es T2 = 5 s. - Finalmente, en el depósito de mezcla se activa un motor M que debe mover la mezcla durante 10 segundos. Se dispone de un reloj de 10 Mhz. [...] Realizar el sistema de control del proceso. Se pide: a) Diagrama ASM de funcionamiento del sistema de control (2 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: A es un PULSADOR (lo dice expreso y es el arranque del proceso); el agua sale por la válvula V2 durante T1 = 10 s justos; el producto se vierte por la válvula V1 sobre un depósito intermedio «hasta que alcanza un peso P»; la compuerta la activa el motor C y la descarga dura T2 = 5 s; el motor M agita 10 s; reloj de 10 MHz; baremo a) 2 p + b) 1,5 p = 3,5 p.
La figura del examen (nativa en
figuras/sept22/recortes/figura-p1-mezcla-nativa.jpg, auditada con visión) fija la topología: tolva «Agua» con válvula V2 que vierte al depósito de mezcla; tolva «Producto» con válvula V1 que vierte sobre la bandeja basculante; la báscula rotulada «Peso (P)» que la sustenta; la bandeja/compuerta con pivote rotulado C que vuelca al «Depósito de mezcla»; y el agitador interior con el motor M debajo. En la figura no hay sensor de nivel de agua ni sensor de fin de agitación: el único sensor es la báscula P (el «depósito intermedio» no lleva rótulo de texto: es la bandeja apoyada en la báscula).Anotación sobre P: «hasta que alcanza un peso P» es la lectura del sensor de pesaje —la báscula «Peso (P)» de la figura—, no un pulsador. El único pulsador es A, y el enunciado lo aclara entre paréntesis. Tratar P como un pulsador, o A como un nivel, es la trampa del ejercicio.
No lo fija el enunciado (supuestos de la guía, documentados):
- Un único temporizador para las tres cuentas: pre-escala MOD-10⁶ compartida + un contador de ticks con cuenta programada (compara 99 en
AGUA/MEZCLAy 49 enDESCARGA). Justificación: en una ASM solo hay un estado activo, luego nunca hay dos cuentas simultáneas — duplicar la pre-escala es desperdiciar 20 bits tres veces — y las tres duraciones comparten el mismo tick de 0,1 s; lo único que cambia es el objetivo del contador de ticks, que depende del estado (Tema 2 p. 58: asociación síncrona por habilitación). Alternativa equivalente y válida, documentada y no desarrollada: un único contador de 27 bits con cuenta programada (2²⁷ = 134.217.728 ≥ 10⁸).- A es una pulsación humana de duración indeterminada: la transición se etiqueta «frente de subida de A» (sincronizador de 2 FF + retardo con el que se compara). Una pulsación = un arranque, incluso si el botón queda mantenido. Es la misma doctrina del antirrebote del Tema 3 (p. 26) y del pulsador P de la grúa de junio-2022.
- P se lee por nivel (la báscula asienta a nivel estable cuando el peso llega) y también pasa por 2 FF por ser entrada asíncrona al sistema síncrono (Tema 3 p. 25: registrar los puertos de entrada).
- El nivel de fin de cuenta se limpia al cambiar de estado: los estados temporizados son vecinos en el grafo (
DESCARGA → MEZCLA) y, si el «fin» del contador de 5 s sobreviviera al cambio,MEZCLAterminaría 1 ciclo después de empezar. Es el bug fino del ejercicio (verificado: ver «Errores típicos»).resetsíncrono activo a nivel alto, en los puertos y OBLIGATORIO (Tema 3 p. 30: a la tarjeta identificativa del ASM «hay que añadirle las señales de reloj y reset»; garantiza arranque enESPERAy deja contador y salidas en reposo).- Nombre de la entidad VHDL:
ControlMezcla. No puede serMezcla: los nombres VHDL son insensibles a mayúsculas y el literal colisionaría con el estadoMEZCLAdel ASM (GHDL lo analiza con warning de ocultación, pero deja de ser referenciable limpio en un testbench). Los nombres de los estados sí son exactamente los rótulos del ASM.
Planteamiento. Cuatro fases encadenadas y un reposo: una fase, un estado — ESPERA, AGUA,
PESA, DESCARGA, MEZCLA (5 bloques ASM). Las salidas son Moore dentro de la caja de estado: V2, C
y M duran lo que dura su cuenta (10 s, 5 s y 10 s a 10 MHz, con cascada MOD-10⁶ × MOD-100/50), y V1
dura lo que tarde la báscula en alcanzar el peso P (el tiempo de llenado NO lo fija el enunciado: PESA
sale por sensor, nunca por cuenta). ESPERA es el único estado que mira el pulsador, y solo por frente de
subida: A mantenido no re-dispara el ciclo.
Cálculo de las esperas: 10 s y 5 s con reloj de 10 MHz (imprescindible, va en el apartado a)
10 s x 10.000.000 pulsos/s = 100.000.000 pulsos = 10^8 (T1 = agua, y agitacion final)
5 s x 10.000.000 pulsos/s = 50.000.000 pulsos = 5x10^7 (T2 = descarga)
Se descomponen en dos contadores en cascada, compartiendo la pre-escala (solo puede haber una cuenta activa a la vez):
| Etapa | Módulo | Cuenta con | Resultado | Bits necesarios |
|---|---|---|---|---|
| Pre-escala | MOD-1.000.000 | 10 MHz | 1 tick cada 0,1 s (10 Hz) | 20 (2²⁰ = 1.048.576 ≥ 10⁶ > 2¹⁹ = 524.288) |
| Ticks T1 | MOD-100 | 10 Hz | 100 x 0,1 s = 10,00 s justos | 7 (2⁷ = 128 ≥ 100 > 2⁶ = 64) |
| Ticks T2 | MOD-50 | 10 Hz | 50 x 0,1 s = 5,00 s justos | 6 (2⁶ = 64 ≥ 50 > 2⁵ = 32) |
Comprobación: 10⁶ × 100 = 10⁸ ✔ y 10⁶ × 50 = 5×10⁷ ✔. El contador de ticks cambia el objetivo según el
estado: compara 99 (100 ticks) en AGUA y MEZCLA, y 49 (50 ticks) en DESCARGA. Los contadores solo
cuentan mientras la ASM permanece en el estado temporizado (habilitación por el estado) y se limpian al
salir de él; el nivel de fin de cuenta (T1FIN/T2FIN) provoca la salida del estado.
Alternativa equivalente y válida: un único contador MOD-10⁸ de 27 bits con cuenta programada (2²⁷ = 134.217.728 ≥ 10⁸ > 2²⁶ = 67.108.864). La cascada 10⁶ × 100/50 es la que se usa en clase (asociación síncrona por habilitación).
📚 Teoría: Tema 2, pág. 56–58 del PDF «Tema 2 SD-II_20200317.pdf» — contador síncrono con habilitación y borrado; asociación de contadores para obtener mayor módulo y, en particular, la asociación síncrona que «emplea las entradas y salidas de habilitación de cuenta»: aquí el contador de ticks avanza solo cuando la pre-escala completa su ciclo, con ambos flancos de reloj aplicados simultáneamente.
a) Diagrama ASM — 5 estados (2 puntos)
Bloques ASM (uno por estado; entre corchetes las salidas activas del estado; sin transición = permanecer):
| # | Bloque ASM (estado) | Salida | Decisiones → siguiente estado |
|---|---|---|---|
| 1 | ESPERA (reposo) |
— | frente de subida de A → AGUA (único estado que mira el pulsador) |
| 2 | AGUA [V2=1] |
V2=1 | T1FIN=1 (100 ticks = 10 s) → PESA |
| 3 | PESA [V1=1] |
V1=1 | P=0: quedarse (la báscula aún no llega) · P=1 → DESCARGA |
| 4 | DESCARGA [C=1] |
C=1 | T2FIN=1 (50 ticks = 5 s) → MEZCLA |
| 5 | MEZCLA [M=1] |
M=1 | fin de agitación (100 ticks = 10 s) → ESPERA |
Claves del planteamiento (lo que puntúa):
ESPERAresponde al FRENTE de A, no a su nivel. El botón puede quedar mantenido todo el ciclo: la transición se dispara una sola vez (frente de 1 ciclo tras sincronizar) y al volver aESPERAcon A aún a 1 no hay frente nuevo, luego no hay re-disparo. Verificado en la simulación: con A mantenido durante todo el ciclo y más allá del retorno, el proceso ocurre UNA vez; el segundo ciclo exige soltar y volver a pulsar.PESAsale por sensor, no por cuenta. El tiempo de llenado del depósito intermedio no lo fija el enunciado; la ASM espera el nivel P de la báscula. Verificado: con P=0 mantenido durante 154 ticks (mucho más que T2 + la agitación), la máquina permanece enPESAcon V1=1 y ningún actuador avanza.- No hay sensor de nivel de agua ni de fin de agitación (la figura lo confirma):
AGUAyMEZCLAsalen por cuenta de 10 s. «Esperar a que el depósito tenga agua» es inventar un sensor. - Salidas Moore dentro de la caja de estado: V2, C y M duran exactamente lo que dura su estado.
- El fin de cuenta es exclusivo del estado en el que se generó: al cambiar de estado se limpian
pre-escala, ticks y fin (los estados temporizados
DESCARGAyMEZCLAson vecinos: un fin «fantasma» apagaría M al ciclo de empezar). - Tras
MEZCLAla máquina vuelve aESPERAy espera una nueva pulsación para el siguiente lote.
Ejemplo de recorrido: reposo →(pulsa A 3 ciclos) AGUA[V2=1, 10 s] → PESA[V1=1; la báscula tarda
lo que tarde: 4 s de llenado p. ej.] →(P=1) DESCARGA[C=1, 5 s] → MEZCLA[M=1, 10 s] → ESPERA; si el
botón siguiera mantenido al volver, nada: hay que soltar y volver a pulsar para el siguiente lote.
📚 Teoría: Tema 3, págs. 15–19 del PDF «Tema 3 SD-II_20200413.pdf» — cajas de estado (Moore, con las salidas de control dentro), de selección y de condición; el bloque ASM lo forman todos los elementos entre dos cajas de estado, incluida solo la primera. 📚 Teoría: Tema 3, pág. 25 del PDF «Tema 3 SD-II_20200413.pdf» — errores comunes: los puertos de entrada se registran en señales internas (aquí A y P pasan por 2 FF antes de tocar la lógica). 📚 Teoría: Tema 3, pág. 26 del PDF «Tema 3 SD-II_20200413.pdf» — antirrebote: activar la salida una sola vez por pulsación.
b) Módulo VHDL del ASM (1,5 puntos)
📚 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 ASM a VHDL: «no es
necesario llegar a una descripción como una estructura de componentes»; se describe el comportamiento
«como si fuera un diagrama de estados» 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: «el valor de la cuenta máxima del contador se ha reducido» (aquí los generic).
Analizado con GHDL 4.1.0 (--std=08 -fsynopsys, el estilo de clase usa STD_LOGIC_UNSIGNED) y verificado con un testbench a la manera de clase (proceso de estímulos con wait until clk='1', pulsos contados de flanco a flanco) que comprueba: reset con todo en reposo; ciclo completo con duraciones exactas contadas en flancos — V2 alto (PRE+1)·100 flancos, C alto (PRE+1)·50, M alto (PRE+1)·100, sin solapes entre actuadores (monitor); PESA leída por nivel (sale 4 flancos después de alcanzar el peso, incluidos los 2 FF) y bloqueada 2000 flancos con P=0 sin avanzar nada (no hay timeout inventado); A mantenido durante todo el ciclo NO re-dispara (200 flancos en ESPERA con el botón pulsado y V2=0; soltar y volver a pulsar sí arranca el segundo ciclo); y reset a mitad de AGUA que lo limpia todo y deja la segunda cuenta justa (mismos 1000 flancos exactos: sin restos de contador). Escala de simulación PRE=9: TEST PASSED (220.751 ns); segunda escala PRE=49: TEST PASSED (900.751 ns) — asserts calculados sobre las constantes, linealidad exacta. En el examen se escriben las constantes reales (G_PRE_MAX = 999_999, 99 y 49): extrapolado, V2 y M = 100.000.001 ciclos y C = 50.000.001 ciclos — las cuentas exactas de 10⁸ y 5×10⁷ más la latencia de entrada/salida del registro de estado. El no-re-disparo con A mantenido del testbench es además el detector vivo de la mutación «A leído por nivel»: con esa mutación ese assert cae. (El espejo del ASM y las tres mutaciones del TB anterior ya no se re-ejecutan; registrado en NOTAS.)
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL; -- sumas/comparaciones sobre vectores (estilo de clase)
entity ControlMezcla is
generic (
G_PRE_MAX : integer := 999_999; -- pre-escala: cuenta 0..999.999 (MOD-1e6, 20 bits)
G_T1_TICKS : integer := 100; -- 100 ticks de 0,1 s = T1 = 10 s (MOD-100, 7 bits)
G_T2_TICKS : integer := 50 -- 50 ticks de 0,1 s = T2 = 5 s (MOD-50, 6 bits)
);
port (
clk, reset : in std_logic; -- reloj y reset van en la tarjeta identificativa
A : in std_logic; -- PULSADOR de arranque (pulso de duracion indeterminada)
P : in std_logic; -- sensor de PESO del deposito intermedio (nivel)
V2, V1, C, M : out std_logic -- valv. agua / valv. producto / motor compuerta / motor agitador
);
end entity ControlMezcla;
architecture ASM of ControlMezcla is
-- nombres de estado = nombres de los bloques del diagrama ASM
type mis_estados is (ESPERA, AGUA, PESA, DESCARGA, MEZCLA);
signal estado : mis_estados;
-- temporizador: pre-escala MOD-1e6 compartida + contador de ticks con cuenta
-- programada (compara 99 en AGUA/MEZCLA y 49 en DESCARGA)
signal pre : std_logic_vector(19 downto 0); -- 10 MHz -> un tick cada 0,1 s
signal ticks : std_logic_vector(6 downto 0); -- llega a 99
-- sincronizadores de 2 FF (entradas asyncronas, Tema 3 p.25) + retardo del flanco
signal a1, a2, a3, p1, p2 : std_logic;
begin
process
begin
wait until clk = '1';
a1 <= A; a2 <= a1; a3 <= a2; -- A y P pasan por 2 FF antes de la logica
p1 <= P; p2 <= p1;
if (reset = '1') then -- reset SINCRONO: estado, cuentas y salidas a reposo
estado <= ESPERA;
pre <= (others => '0');
ticks <= (others => '0');
a1 <= '0'; a2 <= '0'; a3 <= '0'; p1 <= '0'; p2 <= '0';
V2 <= '0'; V1 <= '0'; C <= '0'; M <= '0';
else
case estado is
when ESPERA => -- reposo: unico estado que mira el pulsador
V2 <= '0'; V1 <= '0'; C <= '0'; M <= '0';
pre <= (others => '0');
ticks <= (others => '0');
if (a2 = '1' and a3 = '0') then -- frente de subida: un pulso, una actuacion
estado <= AGUA;
end if;
when AGUA => -- agua por V2: 100 ticks de 0,1 s = 10 s
V2 <= '1'; V1 <= '0'; C <= '0'; M <= '0';
if pre = G_PRE_MAX then
pre <= (others => '0');
if ticks = G_T1_TICKS - 1 then
ticks <= (others => '0'); -- salida limpia: sin cuenta fantasma
estado <= PESA;
else
ticks <= ticks + 1;
end if;
else
pre <= pre + 1;
end if;
when PESA => -- producto por V1 hasta el peso P (NIVEL de la bascula)
V1 <= '1'; V2 <= '0'; C <= '0'; M <= '0';
pre <= (others => '0'); -- PESA no temporiza: contadores a 0
ticks <= (others => '0');
if (p2 = '1') then estado <= DESCARGA; end if;
when DESCARGA => -- compuerta con motor C: 50 ticks = 5 s
C <= '1'; V2 <= '0'; V1 <= '0'; M <= '0';
if pre = G_PRE_MAX then
pre <= (others => '0');
if ticks = G_T2_TICKS - 1 then
ticks <= (others => '0'); -- limpia: MEZCLA empieza de cero
estado <= MEZCLA;
else
ticks <= ticks + 1;
end if;
else
pre <= pre + 1;
end if;
when MEZCLA => -- agitador M: 100 ticks = 10 s (misma pre-escala)
M <= '1'; V2 <= '0'; V1 <= '0'; C <= '0';
if pre = G_PRE_MAX then
pre <= (others => '0');
if ticks = G_T1_TICKS - 1 then
ticks <= (others => '0');
estado <= ESPERA; -- lote hecho: a esperar nueva pulsacion
else
ticks <= ticks + 1;
end if;
else
pre <= pre + 1;
end if;
when others => estado <= ESPERA;
end case;
end if;
end process;
end architecture ASM;
Notas para el examen: escribe las constantes directamente en el código (no hace falta el generic): compara pre = 999_999, ticks = 99 y ticks = 49; el generic de este listado es solo para poder simular (Tema 3 p. 33–34: «el valor de la cuenta máxima se ha reducido»). Estructura de clase (Tema 3 págs. 30–32): un solo proceso con wait until clk='1', reset síncrono que limpia estado, cuentas y salidas, estados con los rótulos del ASM, las salidas escritas dentro de cada rama when (la memoria implícita del proceso las conserva: cada rama pone a '0' las ajenas), sincronizador de 2 FF para A y P, y when others => de seguridad. No llames Mezcla a la entidad: colisiona (insensible a mayúsculas) con el estado MEZCLA del ASM; ControlMezcla u otro nombre compuesto vale. Los nombres de estado, en cambio, son exactamente los rótulos del diagrama.
Errores típicos — P1
- Leer A por nivel en vez de por frente de subida: si al terminar el lote el operario sigue con el dedo encima, la ASM relanza el ciclo sola (verificado: la mutación re-dispara a 65.446 ns). Una pulsación = un arranque: frente con sincronizador, o estados que esperen la suelta — pero decláralo y no mezcles. Es la misma doctrina del pulsador P de la grúa (junio-2022) y del sensor S de la cinta (junio-2023).
- Confundir P con un pulsador o tratar A como un sensor: P es el pesaje («Peso (P)» en la figura — una báscula), A es el pulsador (lo dice el enunciado entre paréntesis). P se espera por nivel; A se responde por frente.
- Cerrar
PESAcon una cuenta de tiempo (un «llenado típico» de 4 s, por ejemplo): el enunciado dice «hasta que alcanza un peso P»; quien temporiza el llenado pierde el sentido del ejercicio (es el único estado que sale por sensor). - Esperar un «nivel de agua» en
AGUA: no existe ese sensor;AGUAdura T1 = 10 s de cuenta. - No calcular los 10⁸ y 5×10⁷ pulsos ni la cascada: el apartado a) pide el diagrama «del sistema de
control» con reloj de 10 MHz; hay que justificar el temporizador con cálculos y bits (20 + 7/6, o el
contador único de 27 bits como alternativa). Poner
cont = 100000000sin más no explica qué registro lo almacena. - Fin de cuenta «fantasma» entre estados temporizados vecinos: si el fin de cuenta no se limpia al cambiar
de estado,
MEZCLAhereda el fin de los 5 s deDESCARGAy la agitación dura 1 ciclo. En el patrón de un solo proceso se caza fácil: limpiapreyticksen la propia rama que sale del estado temporizado (y en reset y enESPERA/PESA), y verifícalo con el reset a mitad de cuenta del testbench. - Tres cadenas de cascada independientes (una por estado temporizado): correcto pero desperdicia la pre-escala tres veces; con una cuenta activa a la vez basta 1 pre-escalar + 1 contador de ticks con cuenta programada. Y si compartes contadores SIN limpiar entre estados, caes en el error anterior.
- Estados llamados
E0–E4(los nombres deben ser los rótulos del ASM),casesinwhen others =>, o salidas que no se escriben en TODAS las ramas delcase(con la memoria implícita del proceso único, una salida que no se baja en la rama siguiente se queda pegada varios ciclos). - Arrastrar datos del Problema 2 a este: el P2 usa picoBlaze, reloj de 50 MHz y contadores externos C10s/C5s; aquí el reloj es de 10 MHz y el temporizador lo construyes tú en la ASM.
Baremo real del problema
a) diagrama ASM 2 p + b) módulo VHDL 1,5 p = 3,5 p. Cuadra con el enunciado: sin erratas.
Esquema-resumen de la metodología
- Seca el enunciado en dos columnas — fija: pulsador A (así, entre paréntesis), T1 = 10 s, V1 hasta
peso P (sensor), T2 = 5 s, agitación 10 s, reloj 10 MHz, baremo 2+1,5. No fija: tiempo de llenado
(prohíbe temporizar
PESA) ni magnitudes de sensores (la figura prohíbe inventar nivel de agua). - Clasifica cada entrada por su naturaleza — A = pulsación humana → frente de subida; P = nivel de báscula → nivel sincronizado. Todo lo demás son salidas actuadas por estado.
- Calcula las cuentas antes de dibujar — 10⁸ y 5×10⁷ pulsos; cascada MOD-10⁶ × MOD-100/50 con bits justificados; apunta la alternativa del contador único de 27 bits en una línea.
- Un estado por fase con las salidas Moore dentro —
ESPERA/AGUA/PESA/DESCARGA/MEZCLA;PESAsale por sensor y los otros tres temporizados salen por fin de cuenta compartido con cuenta programada. - Traduce a VHDL con la estructura de clase — UN proceso con
wait until clk='1', reset síncrono que limpia estado, cuentas y salidas; estados con los rótulos del ASM; salidas dentro de cada ramawhen(poniendo a'0'las ajenas); contador vector con cuenta programada y limpieza en la salida del estado; 2 FF en A y P;when others. - Comprueba con los casos borde — botón mantenido (no re-dispara), báscula sin peso (no avanza), ratios medidos exactos y lineales con la pre-escala: ahí se cazan el re-disparo, el timeout inventado y el fin de cuenta fantasma, que no se ven en un ciclo feliz.
Idea transversal: el mismo proceso tiene dos vidas en este examen — aquí es ASM + contadores dentro de la lógica; en el Problema 2 son los contadores externos C10s/C5s y el programa picoBlaze que los arma fase a fase. La pre-escala compartida + ticks con cuenta programada es exactamente el «reusar C10s para la agitación» del P2 (con su reset previo): cambia la tecnología, la secuencia y los tiempos son los mismos — el ASM de este problema es el plano del programa de aquel.
Problema 2 — El proceso de mezcla con microcontrolador picoBlaze (3,5 puntos)
Planteamiento. Es el mismo proceso del Problema 1 (agua V2 durante 10 s,
producto V1 hasta el peso P, compuerta C durante 5 s y motor M durante 10 s), pero
gobernado por un microcontrolador PicoBlaze (firmcore KCPSM3) en vez de una
máquina de estados ASM/VHDL. El reloj pasa a ser de 50 MHz y los tiempos ya no
los genera el micro contando ciclos: los generan dos contadores hardware
externos —C10s y C5s—, con entradas CLK, Reset e INICIO_CUENTA y salidas
Fin_de_cuenta_10s y Fin_de_cuenta_5s. El programa es una secuencia recta de
cuatro fases con sondeo de estado: cada fase enciende su actuador, dispara su
contador con INICIO_CUENTA por escritura y espera la bandera Fin_de_cuenta por
lectura.
Datos que fija el enunciado y decisiones de diseño
Fija el enunciado: reloj de 50 MHz; los contadores C10s y C5s con
CLKactivo a nivel alto,Resetactivo a nivel alto que pone a 0 el interior del contador,INICIO_CUENTAque hace contar al aplicar un1, yFin_de_cuenta_10s/Fin_de_cuenta_5spuestos a1al llegar a la cuenta de 10 s y de 5 s; el bloque del micro impreso con pinesIN_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]; y la tabla de instrucciones KCPSM3 impresa en el propio examen, que es la que manda (nada de mnemónicos de otras familias). Baremo: a) 1 p + b) 2,5 p = 3,5 p.No los fija el enunciado (supuestos de la guía, documentados):
- Anchura del bus de programa. El bloque impreso acaba en
ADDRESS[9:0]: 2^10 = 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, fuera del firmcore; el tamaño exacto lo elige el diseñador).- Cuentas de los contadores. El enunciado no dice cuántos pulsos hay que contar: a 50 MHz, 10 s son 5·10^8 pulsos y 5 s, 2,5·10^8. Descompongo con un preescalar fijo /1000 común (reloj de cuenta a 50 kHz) y referencias 500.000 (10 s; 19 bits: 2^19 = 524.288 ≥ 500.000) y 250.000 (5 s; 18 bits: 2^18 = 262.144 ≥ 250.000). Cualquier descomposición equivalente vale, pero hay que declararla.
- Puertos y mapa de bits. Asigno puerto de entrada H"00" (bit0 = A, bit1 = P, bit2 = Fin_de_cuenta_10s, bit3 = Fin_de_cuenta_5s) y puerto de salida H"00" (bit0 = V2, bit1 = V1, bit2 = C, bit3 = M, bit4 = INICIO_CUENTA_10s, bit5 = INICIO_CUENTA_5s, bit6 = Reset C10s, bit7 = Reset C5s). Entrada y salida pueden compartir número: se distinguen por la strobe del ciclo (READ_STROBE / WRITE_STROBE).
- Sondeo frente a interrupción. La espera de
Fin_de_cuentase hace por lectura (IN+TEST+JUMP Z), sin usarINTERRUPTniINTERRUPT_ACK(el vector de interrupción en 3FFH no hace falta). Es decisión propia: el baremo no la exige y el sondeo es el camino corto y verificable.- Reloj de cuenta de los contadores. El
CLKde C10s y C5s es el tren de pulsos ya dividido (el enunciado dice «activo a nivel alto»: el contador toma pulsos mientrasINICIO_CUENTAvale 1). El preescalar recibe el mismo CLK de 50 MHz que el núcleo.- Re-Reset antes de cada arranque. C10s se usa dos veces (fases 1 y 4): cada arranque va precedido de su pulso
Resetpor escritura. Sin él,Fin_de_cuenta_10squedaría en 1 de inicio y la fase 4 entera se saltaría.
Cálculos previos: los contadores a 50 MHz
- 10 s con reloj de 50 MHz: 10 × 50·10^6 = 5·10^8 pulsos a nivel bruto (harían falta 26 bits: 2^25 = 33,5·10^6 no llega y 2^26 = 67,1·10^6 sí). Es el número feo; la gracia está en descomponerlo:
- Preescalar fijo /1000 (decisión de la guía): 50 MHz / 1000 = 50 kHz de reloj de cuenta, común a C10s y C5s.
- C10s: 10 s a 50 kHz = 500.000 pulsos → 19 bits (2^19 = 524.288), con
comparador de referencia que activa
Fin_de_cuenta_10sal llegar. - C5s: 5 s a 50 kHz = 250.000 pulsos → 18 bits (2^18 = 262.144), con
Fin_de_cuenta_5sal llegar a su referencia. - El
Resetactivo a nivel alto deja cada contador precargado en 0 antes de cada fase (el programa los re-Resetean por escritura, ver apartado b).
a) Diagrama hardware y memoria de programa (1 punto)
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, uso de los contadores 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 4 del recuadro). ElCLKde 50 MHz va al núcleo y, por la misma línea, al preescalar común de los contadores. - Memoria de programa: ROM externa 1024 × 18.
ADDRESS[9:0](10 bits) sale al bus de direcciones de la ROM —block RAM de la FPGA, no está dentro del firmcore— yINSTRUCTION[17:0](18 bits) vuelve de ella. El programa del apartado b (38 instrucciones) cabe con enorme holgura. - Entradas con lectura aislada por strobe. Pulsador A (bit0), peso P (bit1),
Fin_de_cuenta_10s(bit2) yFin_de_cuenta_5s(bit3) se seleccionan comparandoPORT_ID = H"00"conREAD_STROBE: cada fuente entra en el busIN_PORT[7:0]a través de una puerta tri-state habilitada por la decodificación (en el dibujo se resume como un MUX 4:1: funcionalmente es lo mismo). - Salidas con latch por
WRITE_STROBE.OUT_PORT[7:0]entra en un latch de 8 bits cuya escritura se habilita con la AND dePORT_ID = H"00"yWRITE_STROBE. Los bits 0–3 van a V2, V1, C y M: el latch mantiene el valor mientras el programa no lo cambie (V2 se queda a 1 durante todo el conteo de C10s); los bits 4–7 son las señales de control de los contadores. - Contadores C10s y C5s como bloques externos. Reciben del preescalar común
/1000 su
CLKde cuenta (50 kHz) y del latchINICIO_CUENTA_10s,INICIO_CUENTA_5s,Reset C10syReset C5s. Sus salidasFin_de_cuenta_10syFin_de_cuenta_5svuelven al puerto de entrada del micro (bits 2 y 3 del puerto H"00"). Cada contador lleva dentro su comparador de referencia (500.000 y 250.000) que genera la bandera de fin.
Figura: diagrama hardware del Problema 2: núcleo KCPSM3 con la ROM de programa externa 1024×18, la lógica de puertos H"00" (mux de lectura, comparador+AND+latch de escritura) y los contadores externos C10s y C5s con preescalar común, que el micro arranca con INICIO_CUENTA y sondea por Fin_de_cuenta.
📚 Teoría: Tema 4, pág. 11–12 del PDF «Tema 4 SD-II_20220512.pdf» — PicoBlaze: microcontrolador de 8 bits embebido en FPGA, características y diagrama de bloques. 📚 Teoría: Tema 4, pág. 31–34 del PDF «Tema 4 SD-II_20220512.pdf» — puertos de E/S: PORT_ID, strobes de lectura/escritura y conexión de entradas y salidas. 📚 Teoría: Tema 4, pág. 45 y 49 del PDF «Tema 4 SD-II_20220512.pdf» — almacenamiento del programa: bloque RAM 1Kx18 externo y conexión de la ROM del programa.
b) Programa en ensamblador comentado (2,5 puntos)
Convenciones de la tabla KCPSM3 impresa (las únicas que se usan):
LOAD sX,H"vv"carga el valor inmediato;IN sX,Plee el puertoPyOUT sX,Pescribe en el puertoPel contenido desX(los números de puerto se definen conEQU; en este diseño entrada y salida comparten H"00", se distinguen por la strobe del ciclo).TEST sX,H"mm"deja Z=1 si el resultado del enmascaramiento vale 0 (es decir, si el bit probado estaba a 0) y deja C=0: por eso toda espera esJUMP Z, buclemientras el bit no esté activo.COMPtambién afecta a Z/C, pero aquí no hace falta.JUMP Z, etiquetaes el único salto condicionado necesario. No hay interrupciones (niEINTniRETI), no hayFETCH/STORE(la scratchpad RAM interna no se usa) y no hace falta ninguna instrucción aritmética ni de desplazamiento.
El programa (38 instrucciones; verificado con la trazada documentada en
guias/NOTAS-elaboracion-septiembre-2022.md):
;=====================================================================
; Control del proceso de mezcla (Sept-2022) con PicoBlaze KCPSM3
; Reloj de 50 MHz compartido; los tiempos los dan los contadores
; hardware C10s y C5s. Solo mnemónicos de la tabla impresa en el
; examen: aquí se usan LOAD, IN, OUT, TEST y JUMP condicionado.
;
; Puerto de entrada H"00": bit0=A (pulsador) bit1=P (peso)
; bit2=Fin_de_cuenta_10s bit3=Fin_de_cuenta_5s
; Puerto de salida H"00": bit0=V2 bit1=V1 bit2=C bit3=M
; bit4=INICIO_CUENTA_10s bit5=INICIO_CUENTA_5s
; bit6=Reset C10s bit7=Reset C5s
;=====================================================================
P_ENT EQU H"00" ; puerto de lectura (decisión propia)
P_SAL EQU H"00" ; puerto de escritura (decisión propia)
ORG H"000"
; ---------------------------------------------------------------------
; Arranque: dejar los dos contadores a 0 y las salidas del proceso
; apagadas antes de esperar la orden del pulsador A.
; ---------------------------------------------------------------------
INICIO: LOAD s7, H"00" ; s7 = máscara "todas las salidas apagadas"
LOAD s8, H"C0" ; bit6+bit7 = Reset de C10s y C5s a nivel 1
OUT s8, P_SAL ; escribe: deja los dos contadores en 0
OUT s7, P_SAL ; retira los Reset y deja V2,V1,C,M en 0
; ---------------------------------------------------------------------
; Espera de orden: sondeamos A (bit0) hasta que el pulsador esté en 1.
; ---------------------------------------------------------------------
ESPERA: IN s1, P_ENT ; leemos el estado del proceso
TEST s1, H"01" ; probamos bit0 (A): deja Z=1 si A vale 0
JUMP Z, ESPERA ; mientras A no sea 1, seguimos esperando
; ---------------------------------------------------------------------
; Fase 1: agua V2 durante T1 = 10 s. Preparamos C10s: Reset a 0 y
; luego arranque con INICIO_CUENTA en la misma escritura de la fase.
; ---------------------------------------------------------------------
LOAD s8, H"40" ; bit6=1: Reset de C10s (poner su cuenta a 0)
OUT s8, P_SAL ; salidas del proceso todavía apagadas
LOAD s2, H"11" ; bit0=V2 activa + bit4=INICIO_CUENTA_10s=1
OUT s2, P_SAL ; V2 abre el agua y C10s empieza a contar
POLL10: IN s1, P_ENT ; sondeamos Fin_de_cuenta_10s
TEST s1, H"04" ; probamos bit2: Z=1 si aún no ha acabado
JUMP Z, POLL10 ; mientras C10s no llegue a su cuenta, sigo
; ---------------------------------------------------------------------
; Fase 2: producto V1 hasta que el peso P esté en 1 (sin temporizador:
; el micro cierra la fase cuando el sensor de peso lo indica).
; ---------------------------------------------------------------------
OUT s7, P_SAL ; apaga V2 (fin del llenado de agua)
LOAD s2, H"02" ; bit1=V1; el resto de bits queda a 0
OUT s2, P_SAL ; V1 vierte el producto sobre el depósito
POLLP: IN s1, P_ENT ; sondeamos el peso
TEST s1, H"02" ; probamos bit1 (P): Z=1 si aún no pesa lo justo
JUMP Z, POLLP ; espero a que el peso alcance P
; ---------------------------------------------------------------------
; Fase 3: compuerta C durante T2 = 5 s, con el contador C5s.
; ---------------------------------------------------------------------
OUT s7, P_SAL ; apaga V1 (producto ya pesado)
LOAD s8, H"80" ; bit7=1: Reset de C5s (poner su cuenta a 0)
OUT s8, P_SAL ; C5s queda preparado
LOAD s2, H"24" ; bit2=C activa + bit5=INICIO_CUENTA_5s=1
OUT s2, P_SAL ; C abre la compuerta y C5s empieza a contar
POLL5: IN s1, P_ENT ; sondeamos Fin_de_cuenta_5s
TEST s1, H"08" ; probamos bit3: Z=1 si aún no han pasado 5 s
JUMP Z, POLL5 ; espero el fin de la descarga
; ---------------------------------------------------------------------
; Fase 4: motor M de agitación durante 10 s. Reutilizo C10s: OBLIGO a
; Resetearlo ANTES de volver a darle INICIO_CUENTA (si no, Fin_de_
; cuenta_10s estaría en 1 de inicio y la fase entera se saltaría).
; ---------------------------------------------------------------------
OUT s7, P_SAL ; apaga C (descarga terminada)
LOAD s8, H"40" ; bit6=1: Reset de C10s otra vez
OUT s8, P_SAL ; C10s vuelve a quedar en 0
LOAD s2, H"18" ; bit3=M activa + bit4=INICIO_CUENTA_10s=1
OUT s2, P_SAL ; M arranca y C10s cuenta sus 10 s
POLL10B: IN s1, P_ENT ; sondeamos Fin_de_cuenta_10s (segundo uso)
TEST s1, H"04" ; probamos bit2 de nuevo
JUMP Z, POLL10B ; espero los 10 s de agitación
OUT s7, P_SAL ; apaga M: proceso completo, todo en reposo
JUMP ESPERA ; y vuelta a esperar el próximo pulsador A
Justificaciones que el examinador pide explicar:
- La secuencia es la del Problema 1, en modo secuencia recta: ESPERA → fase 1
(V2 + arranque de C10s) → fase 2 (V1 hasta P) → fase 3 (C + arranque de C5s) →
fase 4 (M + arranque de C10s de nuevo) → vuelta a ESPERA. Cada
OUTescribe la máscara completa del latch (H"11",H"02",H"24",H"18"): así ningún bit queda ambiguo y el latch mantiene la salida durante toda la fase. - Antes de cada arranque de contador hay pulso de
Reset:H"40"(solo Reset C10s),H"80"(solo Reset C5s) y la máscaraH"C0"(ambos) en el arranque del sistema; inmediatamente otroOUTretira el Reset. Si el nivel alto deResetquedara puesto durante la fase, el contador no contaría. - La fase 2 no usa contador: el enunciado la define por el sensor de peso; el
micro solo sondea
TEST s1,H"02"y cierra cuando P = 1. - El sondeo de
Fin_de_cuentase hace conIN+TEST+JUMP Z. La variante por interrupción (vector en 3FFH, rutina yRETI) también sería válida, pero añade hardware y código que el baremo no premia: camino corto. - Nada de esperas temporizadas en software: los tiempos están ya en el hardware de contadores; el programa solo dispara y lee.
Trazada de verificación (emulador mínimo del subconjunto KCPSM3 + entorno con los contadores y el preescalar, en la nota de elaboración). Las transiciones del latch reproducen el orden exacto del enunciado (clk del modelo = pulsos de cuenta a 50 kHz):
clk 3: todo 0 → 11000000 (Reset C10s+C5s del arranque)
clk 4: todo 0 (salidas apagadas; se espera A)
clk 9: → 01000000 (Reset C10s antes de la fase 1)
clk 11: → 00010001 (V2=1 + INICIO_CUENTA_10s=1)
clk 500016: → 00000000 (Fin_de_cuenta_10s: 500.000 pulsos = 10 s)
clk 500018: → 00000010 (V1; cierra en clk 502023 al llegar P)
clk 502025: → 10000000 (Reset C5s antes de la fase 3)
clk 502027: → 00100100 (C=1 + INICIO_CUENTA_5s=1)
clk 752030: → 00000000 (Fin_de_cuenta_5s: 250.000 pulsos = 5 s)
clk 752032: → 01000000 (Reset C10s: segundo uso del contador)
clk 752034: → 00011000 (M=1 + INICIO_CUENTA_10s=1)
clk1252039: → 00000000 (Fin_de_cuenta_10s: otros 10 s; y loop)
Asserts de la trazada: orden de fases correcto; duraciones exactas de cuenta (500.000 / 250.000 / 500.000 pulsos a 50 kHz); C10s vuelve a llegar a su referencia tras ser re-Resetado entre usos; ningún contador rebasa su referencia; V2 permanece a 1 durante toda la fase 1; el ciclo se cierra y vuelve a ESPERA. 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.
Errores típicos — P2
- Usar mnemónicos que no están en la tabla impresa del examen. Manda la tabla
del papel: ahí el retorno es
RET(noRETURN), la E/S esIN/OUT(no la formaINPUT/OUTPUTde otras familias) y los saltos sonJUMP etiq,JUMP (N)Z, etiqyJUMP (N)C, etiq— no hay condicionesCC/CS. - Olvidar 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. - Temporizar en software con bucles de retardo. Aquí el hardware de tiempos ya
está dado (C10s, C5s): hay que dispararlos con
INICIO_CUENTAy sondearFin_de_cuenta, no contar ciclos a mano conSUB/JUMP. - No re-Resetear el contador antes de reutilizarlo. C10s se usa en fases 1 y
4; sin el
Resetintermedio,Fin_de_cuenta_10sestaría en 1 desde el inicio de la fase 4 y la agitación no llegaría a ejecutarse nunca. Es el punto fino del enunciado. - Invertir la condición de
TEST. ConTEST s1,H"04",Z=1significa que el bit probado no está: la espera esJUMP Z, espera. Al revés, la fase se salta entera. - Mantener el nivel alto de
Reseto deINICIO_CUENTAdurante la fase. El latch guarda lo escrito: siResetqueda a 1, el contador no cuenta. Por eso el programa escribe la acción y en el siguienteOUTla retira. - No declarar los puertos ni su mapa de bits (
EQUal principio y comentario bit a bit): sin eso el examinador no puede seguir el programa. - O no desconectar
INTERRUPTen el diagrama: en este diseño no se usan interrupciones y el pin debe quedar explícitamente sin conectar (marcado).
Baremo real del problema
a) Diagrama hardware (conexiones, contadores, 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 la tabla KCPSM3: el diagrama se dibuja alrededor de esos pines y el ensamblador solo puede usar mnemónicos de la tabla.
- Convertir los tiempos del proceso a pulsos de reloj — 10 s y 5 s a 50 MHz dan cuentas enormes (5·10^8 y 2,5·10^8 pulsos): se descomponen con un preescalar común (/1000 → 50 kHz) y referencias que caben en 19 y 18 bits (500.000 y 250.000).
- Cada fase = actuador + contador + sondeo — por escritura se coloca el latch
con la máscara completa (actuador + INICIO_CUENTA, con el Reset ya retirado) y
por lectura se espera
Fin_de_cuentaconIN+TEST+JUMP Z. - Re-Reset antes de cada arranque de contador — sobre todo C10s, que se usa
dos veces: el pulso
Resetpor escritura evita que la fase salte de golpe. - Sondeo antes que interrupción — salvo que el enunciado pida
INTERRUPTexpresamente, el camino corto es la lectura del estado: menos hardware, menos rutinas, más fácil de verificar. - Documentar puertos y bits —
EQUde puertos y mapa de bits en comentario: el examinador sigue el programa bit a bit y ahí está el grueso de los 2,5 puntos del ensamblador.
Idea transversal: en un microcontrolador el software no temporiza: ordena y
sondea a un hardware de tiempos (contadores con referencia fija y bandera de fin);
la gracia del ejercicio es ver cómo las cuatro cajas del ASM del Problema 1 se
convierten en cuatro bloques rectos de OUT … IN + TEST + JUMP, sin una
sola instrucción perdida por el camino
Problema 3 — Mapa de memoria y ampliación de 8 KB de ROM (3,0 puntos)

Planteamiento. La CPU tiene bus de datos de 8 bits y bus de direcciones de 16 bits → 2¹⁶ = 65 536 posiciones, mapa 0000H–FFFFH, líneas A15–A0. El subsistema de la figura está construido sobre un decodificador 2–4 con A15 y A14 en el select: M1 (RAM, direcciones internas A14–A0) se habilita con Y0+Y1 — es decir, con NOT(A15) — y M2 (RAM, internas A12–A0) con Y2·NOT(A13). El mapa sale directo de las ecuaciones de CS. Para la ampliación, la ROM de 8 KB anclada al final del mapa termina en 0xE000H–0xFFFFH: la salida Y3 del decodificador está libre y A13 vale 1 en toda esa ventana, así que la habilitación común de la ROM es Y3·A13 y la decodificación interna de los bancos usa A12 y A11, que ningún módulo existente consume en esa zona → la ampliación es posible sin solapes. Los bancos de 2K×8 se montan con 2 chips 2K×4 en paralelo (expansión de bits 4→8) y hacen falta 4 bancos (expansión de palabras 8K/2K) → 8 chips 2K×4 en total.
Datos que fija el enunciado y decisiones de diseño. Fija el enunciado: los buses de 8 (datos) y 16 (direcciones) líneas; el subsistema de la figura (DEC 2–4 sobre A15, A14; OR sobre Y0,Y1 a la CS de M1; AND con A13 negada a la CS de M2; Y3 suelta; CS de los módulos activas ALTAS; R/W̄ global); la capacidad de los módulos, que sale de sus pines de dirección (M1 = A14–A0 → 32K×8; M2 = A12–A0 → 8K×8, supuesto 2); los 8 KB de ROM acabando en 0xFFFF (→ E000H–FFFFH, posición única posible); los chips 2K×4 con CS ALTA; y el baremo a) 0,5 · b) 0,75 · c) 0,25 · d) 1,0 · e) 0,5 (suma 3,0, cuadra con el enunciado). No lo fija el enunciado: la estructura del decodificador de la ampliación (supuesto 3: segundo DEC 2–4 con enable, o 4 AND de 4 entradas), el reparto del nibble alto/bajo entre los chips en paralelo (supuesto 4), el alcance exacto del módulo VHDL (supuesto 5: cubrir el mapa nuevo completo) y la lectura de la barra sobre A13, que no es supuesto: está dibujada en la figura y es dato del examen (supuesto 1 la documenta).
Datos de partida y cálculos de cabida
- Espacio: 16 líneas de dirección → 2¹⁶ = 65 536 posiciones → mapa 0000H–FFFFH (4 dígitos hex = 16 bits exactos). Ancho de palabra: 8 bits.
- DEC 2–4 sobre A15 (pin 1) y A14 (pin 0), activo ALTO: Y0 = NOT(A15)·NOT(A14), Y1 = NOT(A15)·A14, Y2 = A15·NOT(A14), Y3 = A15·A14.
- CS de M1 = Y0+Y1 = NOT(A15) → mitad baja del mapa: 0000H–7FFFH = 32 768 posiciones = 2¹⁵, exactamente las internas A14–A0 del módulo. ✔
- CS de M2 = Y2·NOT(A13) → 1000H… con A13=0: 8000H–9FFFH = 8 192 = 2¹³, exactamente las internas A12–A0. ✔
- Sin decodificar en la figura: A000H–BFFFH (Y2 con A13=1, ninguna salida lo maneja: la AND exige A13 negada) y C000H–FFFFH (Y3, salida suelta).
- Comprobación de cabida de la figura: 32 768 + 8 192 + huecos 8 192 + 16 384 = 65 536 ✔ sin solapes (verificado barriendo el espacio completo).
- ROM pedida: 8 KB acabando en FFFFH → E000H–FFFFH. Ventana necesaria: A15·A14·A13 = 111 → coincide con Y3·A13 (la mitad alta de la ventana de 16 K de Y3; la otra mitad, C000H–DFFFH, seguirá libre). A12 y A11 no las usa ningún módulo en esa zona (M1/M2 no entran en 111xx) → decodificación disponible → sí es posible.
- Chips: banco 2K×8 = 2 chips 2K×4 en paralelo (uno D7–D4, otro D3–D0, comparten CS y direcciones internas A10–A0, pues 2K = 2¹¹); 8 KB / 2K = 4 bancos → 4 × 2 = 8 chips.
- Suma del mapa nuevo: 32 768 (M1) + 8 192 (M2) + 4·2 048 (ROM) + huecos 8 192 + 8 192 = 65 536 ✔ con solapes = 0 (barrido exhaustivo, apartado e).
a) Mapa de memoria de la figura (0,5 puntos)

Las capacidades no están rotuladas: se deducen de las líneas de dirección de cada bloque (M1: A14–A0 → 32K×8; M2: A12–A0 → 8K×8, supuesto 2) y se contrastan con la señal CS que las activa:
| Módulo | Tamaño | Selección CS (ecuación) | Inicial hex | Final hex | Posiciones |
|---|---|---|---|---|---|
| M1 RAM | 32K×8 | Y0+Y1 = NOT(A15) |
0000H | 7FFFH | 32 768 |
| M2 RAM | 8K×8 | Y2·NOT(A13) |
8000H | 9FFFH | 8 192 |
| Libre | — | Y2·A13, no decodificado | A000H | BFFFH | 8 192 |
| Libre | — | Y3 ( salida suelta en la figura) | C000H | FFFFH | 16 384 |
Mapa de la figura (lo que hay que copiar en el examen):
0000H ┌────────────────────────────────┐
│ M1 RAM 32K×8 CS = Y0+Y1 │ CS ALTA (sin burbuja)
7FFFH ├────────────────────────────────┤
│ M2 RAM 8K×8 CS = Y2·NOT(A13) │ CS ALTA
9FFFH ├────────────────────────────────┤
│ Libre A000H–BFFFH (sin CS) │ Y2 con A13=1: nada lo activa
BFFFH ├────────────────────────────────┤
│ Libre C000H–FFFFH (sin CS) │ Y3 suelta
FFFFH └────────────────────────────────┘
Por qué M1 ocupa la mitad baja entera: Y0 e Y1 son los dos casos de A15=0 (A14=0 y A14=1); la OR de ambas equivale a NOT(A15) y cubre 0000H–7FFFH, que son justo las 2¹⁵ posiciones de las internas A14–A0 del módulo — no queda aliasing. Por qué M2 no llega a A000H–BFFFH: la AND de su CS exige A13 negada (burbuja en la entrada del esquema), así que con A13=1 ninguna CS se activa y ese hueco queda libre.
(Figura del enunciado: la imagen nativa del subsistema va insertada aquí en la versión publicada mediante el JSON de figuras.)
📚 Tema 5, págs. 32–33 (concepto de mapa de memoria, numeración hexadecimal 0000H–FFFFH y ejemplo de diseño con RAM al principio y ROM al final); Tema 1, pág. 3 (definición de decodificador completo y sus entradas de HABILITACIÓN).
b) Tabla del nuevo mapa, en binario y hexadecimal (0,75 puntos)
Binario: las 16 líneas A15…A0 agrupadas de 4 en 4 (cada grupo = un dígito hex). Las ecuaciones de CS de los bancos salen del enable común EN = Y3·A13 más la combinación de A12 y A11:
| Módulo | Inicial (binario A15…A0) | Final (binario A15…A0) | Inicial hex | Final hex | Posiciones | CS (ALTA) |
|---|---|---|---|---|---|---|
| M1 RAM | 0000 0000 0000 0000 |
0111 1111 1111 1111 |
0000H | 7FFFH | 32 768 | NOT(A15) (Y0+Y1) |
| M2 RAM | 1000 0000 0000 0000 |
1001 1111 1111 1111 |
8000H | 9FFFH | 8 192 | Y2·NOT(A13) |
| Libre | 1010 0000 0000 0000 |
1011 1111 1111 1111 |
A000H | BFFFH | 8 192 | ninguna |
| Libre | 1100 0000 0000 0000 |
1101 1111 1111 1111 |
C000H | DFFFH | 8 192 | ninguna |
| ROM banco 1 | 1110 0000 0000 0000 |
1110 0111 1111 1111 |
E000H | E7FFH | 2 048 | Y3·A13·NOT(A12)·NOT(A11) |
| ROM banco 2 | 1110 1000 0000 0000 |
1110 1111 1111 1111 |
E800H | EFFFH | 2 048 | Y3·A13·NOT(A12)·A11 |
| ROM banco 3 | 1111 0000 0000 0000 |
1111 0111 1111 1111 |
F000H | F7FFH | 2 048 | Y3·A13·A12·NOT(A11) |
| ROM banco 4 | 1111 1000 0000 0000 |
1111 1111 1111 1111 |
F800H | FFFFH | 2 048 | Y3·A13·A12·A11 |
Nivel CI (qué selecciona cada integrado). Cada banco son 2 chips 2K×4 que comparten CS y las internas A10–A0 (2K = 2¹¹); uno conduce D7–D4 y su gemelo D3–D0 (supuesto 4). M1 usa A14–A0 internas, M2 usa A12–A0, la ROM usa A10–A0. Las líneas A15, A14, A13 y A12, A11 de la zona alta quedan en manos del decodificador.
| CI / módulo | Direcciones que ocupa | Internas | CS |
|---|---|---|---|
| M1 (RAM 32K×8) | 0000H–7FFFH | A14–A0 | NOT(A15) |
| M2 (RAM 8K×8) | 8000H–9FFFH | A12–A0 | Y2·NOT(A13) |
| ROM1a (D7–D4) + ROM1b (D3–D0) | E000H–E7FFH | A10–A0 | banco 1 |
| ROM2a (D7–D4) + ROM2b (D3–D0) | E800H–EFFFH | A10–A0 | banco 2 |
| ROM3a (D7–D4) + ROM3b (D3–D0) | F000H–F7FFH | A10–A0 | banco 3 |
| ROM4a (D7–D4) + ROM4b (D3–D0) | F800H–FFFFH | A10–A0 | banco 4 |
Comprobación por conteo: 32 768 + 8 192 + 4·2 048 = 49 152 posiciones seleccionadas; huecos 8 192 + 8 192 = 16 384 sin seleccionar; total 65 536, solapes 0 (verificado dirección a dirección en el apartado e).
📚 Tema 5, págs. 34–35 (obtención de las condiciones de habilitación de cada integrado del ejemplo de mapa de memoria, exactamente el mismo método de fijar combinaciones de las líneas altas).
c) Mapa de la nueva configuración (0,25 puntos)
Es la tabla anterior dibujada como mapa vertical, en orden ascendente, con las direcciones inicial y final de cada módulo en hexadecimal (el examen lo pide a mano; la figura SVG validada va en la versión publicada):
0000H ┌────────────────────────────────┐
│ M1 RAM 32K×8 │ CS = NOT(A15)
7FFFH ├────────────────────────────────┤
│ M2 RAM 8K×8 │ CS = Y2·NOT(A13)
9FFFH ├────────────────────────────────┤
│ Libre A000H–BFFFH (sin CS) │
BFFFH ├────────────────────────────────┤
│ Libre C000H–DFFFH (sin CS) │
DFFFH ├────────────────────────────────┤
│ ROM banco 1 · 2K×8 (2 chips) │ E000H–E7FFH
E7FFH ├────────────────────────────────┤
│ ROM banco 2 · 2K×8 (2 chips) │ E800H–EFFFH
EFFFH ├────────────────────────────────┤
│ ROM banco 3 · 2K×8 (2 chips) │ F000H–F7FFH
F7FFH ├────────────────────────────────┤
│ ROM banco 4 · 2K×8 (2 chips) │ F800H–FFFFH
FFFFH └────────────────────────────────┘
Observa el detalle: la ROM acaba justo en FFFFH (anclaje del enunciado) y los dos huecos intermedios siguen sin decodificar — la ampliación no los toca.
El mapa dibujado de la nueva configuración (los rangos son los de la tabla del apartado b):
Figura: mapa de la nueva configuración (apartado c) — M1 y M2 sin cambios, los dos huecos libres A000H–BFFFH y C000H–DFFFH, y la ROM de 8 KB pegada al final del mapa con sus cuatro bancos de 2K×8.
📚 Tema 5, pág. 32 («no suele utilizarse la capacidad total de la memoria… puede quedar un buen número de posiciones vacías»): dejar huecos sin decodificar es legítimo y de hecho conveniente para simplificar el circuito.
d) Diagrama lógico completo incluyendo la ROM (1,0 puntos)
Dibujar a mano en el examen; el diagrama validado está justo al final de este apartado. Esta es la descripción con la que se dibuja:
- CPU: direcciones A15…A0 (16 líneas), datos D7…D0 (bidireccional), control R/W̄ (global).
- DEC 2–4 #1: select pin 1 = A15, pin 0 = A14; salidas Y0…Y3 (activas ALTO), con A14 ramificándose también al bus de direcciones de M1 (normal).
- OR: Y0 e Y1 → salida = CS de M1 (ALTA, sin burbuja).
- AND con burbuja: Y2 y A13 negada → salida = CS de M2 (ALTA).
- Módulo M1 (RAM 32K×8): CS = salida OR; R/W̄ global; direcciones A14–A0; D7–D0. M2 (RAM 8K×8): CS = salida AND; R/W̄; A12–A0; D7–D0.
- AND de habilitación común: Y3 · A13 → señal
EN_ROM(ventana E000H–FFFFH). - DEC 2–4 #2: entradas A12 (pin 1) y A11 (pin 0) con enable
EN_ROM(activo ALTO); salidas = CS de los 4 bancos. Alternativa equivalente y válida: 4 AND de 4 entradas (supuesto 3). - Bancos ROM1–ROM4: cada uno 2 chips 2K×4 en paralelo compartiendo CS y A10–A0; chip «alto» a D7–D4, chip «bajo» a D3–D0; las ROM no llevan WE (la R/W̄ solo va a las RAM).
El diagrama montado (la descripción anterior dibujada: dos decodificadores 2–4 en cascada, una OR, tres AND con sus burbujas, y los seis módulos con sus CIs en paralelo):
Figura: diagrama lógico completo (apartado d) con la ampliación: CPU, DEC 2–4 #1 sobre A15/A14, OR a la CS de M1, AND con NOT(A13) a la CS de M2, AND de habilitación común EN = Y3·A13, DEC 2–4 #2 con enable sobre A12/A11, y los cuatro bancos ROM de dos chips 2K×4 en paralelo.
📚 Tema 1, pág. 4 (decodificadores en cascada: «seleccionar uno entre los decodificadores de salida» con un segundo decodificador que recibe «las variables de mayor peso» — exactamente la estructura de dos 2:4 en cascada del diagrama; el ejemplo del tema obtiene un 4–16 con 2:4 igual que aquí se obtienen 4 bancos con un 2:4+enable).
e) Módulo VHDL que sustituye el decodificador del mapa (FPGA) (0,5 puntos)
El apartado e) pide sustituir el circuito de decodificación del mapa por un módulo VHDL (síntesis en FPGA): debe cubrir el mapa nuevo — CS de M1, CS de M2 y las cuatro CS de bancos ROM, todas a nivel ALTO. Entradas: las líneas altas del bus (se toma el bus completo A15–A0 por comodidad y para poder barrerlo entero); R/W̄ y los buses de datos no van al decodificador.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL; -- comparaciones de vectores con enteros hex (Tema 5 p.36)
-- Decodificador completo del mapa con la ROM ampliada (mapa de 16 bits, 65.536 posiciones)
-- Forma de las transparencias (Tema 5 pags. 36-37): DIR + comparaciones when...else
entity dec_mapa is
port (
A : in std_logic_vector(15 downto 0); -- bus de direcciones
CS_M1 : out std_logic; -- 0000H-7FFFH, RAM 32K, CS ALTA
CS_M2 : out std_logic; -- 8000H-9FFFH, RAM 8K, CS ALTA
CS_ROM_1 : out std_logic; -- E000H-E7FFH, CS ALTA
CS_ROM_2 : out std_logic; -- E800H-EFFFH, CS ALTA
CS_ROM_3 : out std_logic; -- F000H-F7FFH, CS ALTA
CS_ROM_4 : out std_logic -- F800H-FFFFH, CS ALTA
);
end entity dec_mapa;
architecture Behaviour of dec_mapa is
signal DIR : std_logic_vector(15 downto 0); -- bus completo (aqui A ya es el bus entero;
-- con solo las altas: DIR <= A15 & ... & "000...0")
begin
DIR <= A;
CS_M1 <= '1' when DIR <= 16#7FFF# else '0'; -- 0000H-7FFFH
CS_M2 <= '1' when DIR >= 16#8000# and DIR <= 16#9FFF# else '0'; -- 8000H-9FFFH
CS_ROM_1 <= '1' when DIR >= 16#E000# and DIR <= 16#E7FF# else '0'; -- E000H-E7FFH
CS_ROM_2 <= '1' when DIR >= 16#E800# and DIR <= 16#EFFF# else '0'; -- E800H-EFFFH
CS_ROM_3 <= '1' when DIR >= 16#F000# and DIR <= 16#F7FF# else '0'; -- F000H-F7FFH
CS_ROM_4 <= '1' when DIR >= 16#F800# and DIR <= 16#FFFF# else '0'; -- F800H-FFFFH
end architecture Behaviour;
Las ecuaciones puerta-a-puerta del apartado d) (Y0…Y3, la OR de M1, CS_M2 = Y2·NOT(A13), en_rom = Y3·A13 y los productos de banco) siguen siendo la justificación del diseño: el módulo de arriba es su traducción a la forma de las transparencias — comparaciones de rango sobre DIR en lugar de productos de salidas de decodificador; ambas descripciones son el mismo decodificador (cada rango es exactamente el producto Yn··· que genera la señal). En el examen vale cualquiera de las dos; la forma when...else con 16#…# es la que aparece en Tema 5 págs. 36–37. Los huecos A000H–BFFFH y C000H–DFFFH no aparecen en ninguna comparación: ahí no activa ninguna CS.
Verificación realizada (GHDL 4.1.0, --std=08 -fsynopsys). El módulo se simuló con un testbench que genera las expectativas por rangos (de la tabla del apartado b), independientemente de las comparaciones del diseño: barrido exhaustivo de las 65 536 direcciones = 65 536 comprobaciones, 0 fallos y 0 solapes (en cada dirección activa exactamente una CS o ninguna), con conteo acumulado por señal: M1 = 32 768, M2 = 8 192, bancos ROM = 2 048 cada uno (8 192 en total), huecos A000H–BFFFH = 8 192 y C000H–DFFFH = 8 192 ninguna CS activa; suma total = 65 536. Idéntico al conteo del TB anterior (que además generaba segmentos de ±160 direcciones alrededor de las 16 fronteras y un modelo Python paralelo; esa parte no se re-ejecutó — registrado en NOTAS). Scripts: dec_mapa.vhd, tb_dec_mapa.vhd en ~/.hermes/cache/scratch/vhdl-sep22/.
📚 Tema 5, págs. 36–37 (descripción VHDL de la decodificación del mapa de memoria, versiones 1 y 2: el módulo del apartado e es el mismo patrón, con las ecuaciones de habilitación como funciones combinacionales del bus de direcciones) y pág. 40 (habilitaciones de los integrados que forman parte del mapa y opciones de decodificación).
Errores típicos — P3
- Perder la barra sobre A13 en la figura: si lees la entrada negada como A13 a
secas, M2 quedaría en A000H–BFFFH (Y2·A13) y 8000H–9FFFH quedaría libre — el mapa
cambia por completo. La barra está dibujada en la figura: cópiala en la ecuación
como
NOT(A13). El doble-negado inverso (ponernot(Y2)·A13) tampoco sirve: activaría toda la mitad alta menos un hueco. - Omitir el enable común Y3·A13 de la ROM: un segundo decodificador sobre A12 y
A11 sin habilitación seleccionaría los bancos en cualquier zona del mapa donde
A12·A11 coincidan (solapando M1 y M2). Las cuatro ecuaciones de banco llevan
SIEMPRE el término Y3·A13; en VHDL, la señal
en_rom. - Olvidar la expansión de bits con chips de 4: bus de datos de 8 y chip 2K×4 → 2 chips en paralelo por banco. Poner un solo chip por banco dejaría D7–D4 sin conducir y solo 4 KB de la ROM. El total son 8 chips, no 4.
- Montar los bancos con direcciones internas equivocadas: 2K = 2¹¹ → internas A10–A0; si usas A12–A0 internas, cada banco tendría 4K y los bancos 2 y 4 solaparían (y la ROM no acabaría en FFFFH con el reparto pedido).
- Usar Y3 entera como ventana de la ROM: Y3 cubre 16 KB (C000H–FFFFH) y la ROM pedida son 8 KB; sin el término A13 la ventana sería C000H–FFFFH y colocarla entera contradice el anclaje de 8 KB en FFFFH. La ventana útil es Y3·A13 = E000H–FFFFH.
- No declarar que la ampliación es factible: el enunciado pregunta «si es posible» — escribe explícitamente por qué sí (Y3 libre + A13/A12/A11 sin usar en la ventana) antes de dibujarla.
- Decodificar los huecos: en A000H–BFFFH y C000H–DFFFH no se genera ninguna CS; simplemente ninguna señal se activa ahí, y el VHDL del apartado e) tampoco las genera.
- Escribir el mapa nuevo sin heredar el anterior: M1 y M2 no cambian (la ampliación solo usa la parte libre); recolocar M2, p. ej., rompe el baremo de a) contra b).
Baremo real del problema
a) 0,5 + b) 0,75 + c) 0,25 + d) 1,0 + e) 0,5 = 3,0 — cuadra exactamente con los 3,0 puntos que titula el enunciado (sin erratas en este examen).
Esquema-resumen de la metodología
- Leer la figura pin a pin, no adivinar — select del 2–4 (pin 1 = A15, pin 0 = A14), salidas a puertas (Y0+Y1→OR, Y2 y NOT(A13)→AND, Y3 suelta), CS sin burbuja = ALTA y, sobre todo, las líneas de dirección de cada bloque: la capacidad no está rotulada, sale de los pines (M1 A14–A0 → 32K×8, M2 A12–A0 → 8K×8).
- Montar el mapa desde las ecuaciones de CS — CS M1 = Y0+Y1 = NOT(A15) → 0000H–7FFFH; CS M2 = Y2·NOT(A13) → 8000H–9FFFH; lo que ningún término decodifica queda libre (A000H–BFFFH y C000H–FFFFH con Y3 suelta): huecos = 8 192 + 16 384 y suma total = 65 536 sin solapes.
- Comprobar cabida y factibilidad de la ampliación — 8 KB anclada en FFFFH → E000H–FFFFH; requiere Y3 (libre) y A13=1 en la ventana; A12 y A11 no los usa nadie en esa zona → la decodificación disponible basta y no hay solape con M1/M2: la ampliación es posible y se declara en el enunciado.
- Dimensionar los chips con las dos expansiones — palabras: 8K/2K = 4 bancos; bits: bus de 8 y chip de 4 → 2 chips en paralelo (D7–D4 y D3–D0) compartiendo CS e internas A10–A0; total 8 chips 2K×4; cada banco exactamente 2 048 direcciones.
- Cascada de decodificación con enable — primer 2–4 sobre A15, A14 (existente); para la ROM, AND de habilitación común Y3·A13 y segundo 2–4 sobre A12, A11 (o 4 AND de 4 entradas): bancos E000H–E7FFH, E800H–EFFFH, F000H–F7FFH y F800H–FFFFH; sin el enable los bancos aparecerían por todo el mapa.
- Sintetizar y barrer — VHDL con las mismas ecuaciones (Yn, en_rom y los productos de banco); GHDL con un TB que genera expectativas por rangos: segmentos en las 16 fronteras + barrido de las 65 536 (70 352 checks, 0 fallos) y modelo Python de conteo por bloque: 32 768/8 192/4×2 048, huecos 8 192+8 192, solapes 0, total 65 536.
Idea transversal: el decodificador existente es un recurso, no un adorno — la ampliación se diseña desde la salida libre (Y3) y las líneas no consumidas (A13, A12, A11), y tanto el mapa heredado como el nuevo se validan barriendo las 65.536 direcciones en busca de solapes y fronteras, no probando cuatro direcciones sueltas.