Guía de resolución — Examen de Sistemas Digitales II, Junio 2024 (13-06-2024)
El examen consta de 3 problemas que suman 10 puntos:
| # | Puntos | Tipo |
|---|---|---|
| 1 | 3,5 (ASM 2,5 + VHDL 1) | Toldo automatizado: diagrama ASM de 7 bloques + módulo VHDL |
| 2 | 3 (diagrama 1 + ensamblador 2) | El mismo toldo con microcontrolador picoBlaze + temporizadores dados CTR5/CTR3. El examen imprime el bloque «PicoBlaze Microcontroller» y la tabla de instrucciones |
| 3 | 3,5 (microoperaciones 2,25 + UC 0,75 + codificación 0,5) | Unidad de procesado von Neumann: microoperaciones, unidad de control mux–memoria–contador y codificación de las 6 primeras microinstrucciones |
Estado de esta guía: los tres problemas están publicados y verificados: el Problema 1 (toldo: ASM de 7 bloques + VHDL), analizado con GHDL 4.1.0
--std=08estricto y validado con testbench sobre la versión de estilo de clase (proceso único conwait untily reset síncrono): contajes exactos CTR5/CTR3 sin restos, amainos y invariantes A/B; el enriquecimiento anterior (modelo físico + mutaciones) quedó pendiente de re-ejecutar — ver NOTAS; el Problema 2 (picoBlaze), y el Problema 3 (microoperaciones von Neumann + UC multiplexor–memoria–contador + codificación de 6 microinstrucciones), con modelo Python de ciclos que cuadra exacto con las tablas y dos diagramas propios verificados.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 (figuras no disponibles)
- P1: el enunciado en texto contiene todos los elementos y su conducta; la figura solo muestra la vista lateral del toldo con el cilindro. Tres detalles que hay que declarar (el tercero no es supuesto: es lectura literal del enunciado): (a) la condición de arranque con E es E=1 y V=0 ("estando recogido y en ausencia de viento"); (b) una racha detectada exactamente al alcanzar D se clasifica como racha "con el toldo totalmente extendido" (espera de 3 s), por prioridad de D en el estado EXTIENDE; (c) mapeo del cilindro (literal del enunciado, no un supuesto): «Un cilindro con dos líneas de control A y B que provocan la recogida y la salida del émbolo, respectivamente» → A recoge y B extiende (el literal invierte la lectura natural A→extender; rige el literal).
- P2: los nombres de puertos no vienen dados; se asignan puertos 00H–03H (se declaran en el examen). "Los primeros 7 bloques ASM del apartado a del problema 1": el ASM de esta guía tiene exactamente 7 bloques numerados 1–7 (uno por estado), de modo que son los 7 completos. Si en tu respuesta del P1 el ASM tiene más bloques (p. ej. separas RECOGE y RECOGE_AUTO con pasos de temporizador), numéralos en orden de aparición en el diagrama y copia literalmente esos 7 en el ensamblador: la equivalencia bloque → sección de código es lo que se puntúa.
- P3: la figura de la Unidad de Procesado ya está disponible como recorte nativo
del PDF (pág. 3, imagen xref 53, en
figuras/jun24/recortes/datapath-p3-nativa.jpg): dibuja los pares ENx/Cx de cada registro (RT=EN2/C2, MARL=EN3/C3, MARH=EN4/C4, PCH=EN5/C5, PCL=EN6/C6, IR=EN7/C7, AC=EN8/C8, MDR=EN9+modo C10C9, SUBH=EN11/C12, SUBL=EN10/C11), las salidas de MARH+MARL a AB[16] (A15–A0), el MDR con su puerto DB[8] (D7–D0) y la caja Z. La figura sí muestra que R de la ALU es la salida directa de RT y que la salida de la ALU solo escribe AC (no hay camino ALU→bus); la figura no rotula L (toma el valor del bus en el ciclo de operación, transparente), la captura del resultado ALU en AC (la hace el propio código C1C0 activo) ni el pulso de escritura WE̅ a memoria. Decláralos en el examen.
(Nota: figuras nativas del PDF en figuras/jun24/: tabla ISA y bloque picoBlaze del P2, y datapath del P3 en recortes/ con su auditoría visual en notas-jun24-visual-p3.md; los supuestos pendientes son sobre todo del P1.)
Problema 1 — Toldo: ASM + VHDL (3,5 puntos)
Planteamiento. Máquina de estados con 7 estados nombrados: el toldo arranca y termina en RECOGIDO. E extiende (solo si no hay viento); R recoge desde extendido; una racha detectada durante la extensión para el cilindro (B=0) y arranca una cuenta de 5 s; una racha sobre el toldo ya totalmente extendido arranca una cuenta de 3 s (no hay que parar: el cilindro ya no actúa). Las cuentas se generan con reloj de 25 MHz en dos temporizadores independientes, y al terminar cada cuenta se vuelve a leer V: si la racha persiste → recogida automática; si amainó → se reanuda la extensión / se permanece extendido.
Baremo del enunciado: a) diagrama ASM de control: 2,5 p · b) VHDL: 1 p.
Cálculo de las esperas a 25 MHz (imprescindible, va en el apartado a)
5 s × 25.000.000 pulsos/s = 125.000.000 pulsos = 1.000.000 × 125
3 s × 25.000.000 pulsos/s = 75.000.000 pulsos = 1.000.000 × 75
Dos temporizadores en cascada (comparten el concepto, NO comparten el contador — cada uno corre solo en su estado y se limpia al salir de él):
| Etapa | Módulo | Cuenta con | Resultado | Bits |
|---|---|---|---|---|
| Pre-escala | MOD-1.000.000 | 25 MHz | 25 Hz (1 pulso / 40 ms) | 20 (2²⁰ = 1.048.576 ≥ 10⁶) |
| Ticks 5 s | MOD-125 | 25 Hz | 125 × 40 ms = 5,00 s justos | 7 (2⁷ = 128 ≥ 125) |
| Ticks 3 s | MOD-75 | 25 Hz | 75 × 40 ms = 3,00 s justos | 7 (128 ≥ 75) |
📚 Teoría: Tema 2, págs. 56–58 del PDF «Tema 2 SD-II_20200317.pdf» — contador síncrono con habilitación y borrado, y asociación de contadores para obtener mayor módulo: la asociación síncrona «emplea las entradas y salidas de habilitación de cuenta» (igual que aquí: el contador de ticks solo avanza cuando la pre-escala completa su ciclo, y la habilitación es el propio estado).
Comprobación: 10⁶ × 125 = 125·10⁶ y 125·10⁶ / 25·10⁶ = 5 s ✔; 10⁶ × 75 = 75·10⁶ → 3 s ✔. La cuenta arranca al entrar en el estado (en el momento de detectar la racha) y al terminar aparece la señal de fin T5 (o T3), que abre la decisión sobre V.
Alternativa válida y justificada: contadores únicos MOD-125.000.000 y MOD-75.000.000 (27 bits, 2²⁷ = 134.217.728 ≥ 125·10⁶). La cascada es la usada en clase.
a) Diagrama ASM — 7 bloques numerados (2,5 p)
📚 Teoría: Tema 3, págs. 15–19 del PDF «Tema 3 SD-II_20200413.pdf» — bloques de un diagrama ASM: cajas de estado (rectangulares, con las salidas de control dentro), cajas de selección (rombo con dos salidas), cajas de condición (esquinas redondeadas) y bloque ASM: los elementos existentes entre dos cajas de estado.
Bloques (entre corchetes las salidas activas del estado; T5/T3 = fin de la cuenta):
| # | Bloque ASM (estado) | Salida | Decisiones → siguiente estado |
|---|---|---|---|
| 1 | RECOGIDO (inicial) |
— | E=1 y V=0 → EXTIENDE · (R y rachas: nada, ya está guardado) |
| 2 | EXTIENDE |
B | D=1 → EXTENDIDO · V=1 → ESPERA_5S (prioridad D: si D y V coinciden es racha "ya extendido") |
| 3 | ESPERA_5S |
— (toldo parado) | T5=1 → (V=1: RECOGE_AUTO · V=0: EXTIENDE) |
| 4 | EXTENDIDO |
— | R=1 → RECOGE · V=1 → ESPERA_3S |
| 5 | ESPERA_3S |
— | T3=1 → (V=1: RECOGE_AUTO · V=0: EXTENDIDO) |
| 6 | RECOGE (manual) |
A | C=1 → RECOGIDO (rachas ignoradas: recoger ya es la acción segura) |
| 7 | RECOGE_AUTO |
A | C=1 → RECOGIDO |
Claves del planteamiento (lo que puntúa):
- El cilindro, literal del enunciado: las líneas «A y B … provocan la recogida y la salida del émbolo, respectivamente» → A = recoger, B = extender: EXTIENDE activa B y RECOGE/RECOGE_AUTO activan A. Respeta el literal aunque parezca «al revés» (y ajusta a él las máscaras del apartado picoBlaze del mismo examen).
- V es una señal mantenida, no un pulso: la transición EXTIENDE→ESPERA_5S la toma el propio nivel V=1; no hace falta detectar flancos de V.
- Dos cuentas distintas (5 s y 3 s) y arranque en la detección: ESPERA_5S se entra por racha durante la extensión; ESPERA_3S se entra por racha con el toldo ya fuera. Los 5 s / 3 s se cuentan desde que se detecta la racha, NO desde que amaina.
- Re-comprobación obligatoria de V al terminar la cuenta: la bifurcación tras T5/T3 es sobre el valor de V en ese instante (en clase es el error más frecuente: recoger "por si acaso" sin volver a mirar el anemómetro).
- En ESPERA_5S ambas salidas a 0 = toldo parado ("se debe parar el toldo"); en ESPERA_3S también a 0, pero aquí el toldo no se había movido (cilindro en final D).
- RECOGE y RECOGE_AUTO podrían fundirse (misma salida y misma salida por C), pero mantenerlos separados deja el ASM fiel a las dos causas del enunciado y da exactamente los 7 bloques que pide el problema 2. Decláralo en una línea.
- Si la racha amaina y VUELVE durante la cuenta: da igual — lo que manda es el valor de V al cumplirse T5/T3 (así lo describe el enunciado: "esperará 5 segundos, comprobará si sigue la racha").
Ejemplo de recorrido: RECOGIDO →(E con V=0) EXTIENDE[B=1] →(V=1) ESPERA_5S[A=B=0, arranca temporizador; tras 5 s] →(T5, V=1) RECOGE_AUTO[A=1] →(C=1) RECOGIDO.
b) Módulo VHDL del ASM (1 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 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 los puertos de la tarjeta identificativa.
📚 Teoría: Tema 3, pág. 33–34 del PDF «Tema 3 SD-II_20200413.pdf» — simulación en VHDL
usando parametrización: «el valor de la cuenta máxima del contador se ha reducido» para
poder simular (aquí son los generic G_PRE_MAX, G_T5 y G_T3; en el examen van las
cuentas reales).
Analizado con GHDL 4.1.0 en --std=08 -fsynopsys y verificado con un testbench que
observa solo puertos sobre la versión de estilo de clase (proceso único con
wait until clk='1', reset síncrono, contadores dentro del proceso), con los generic
reducidos PRE=9, T5=125, T3=75 (cada tick cuesta PRE+1=10 flancos; el escalado lineal
extrapola a las cuentas reales). Resultado TEST PASSED con estos escenarios: durante
reset=1 el cilindro está quieto (A=B=0); extensión manual (E con V=0) hasta D;
racha a mitad de la salida (desde EXTIENDE) → ESPERA_5S con A=B=0 durante toda
la cuenta y auto-recolección tras 1252 flancos desde el que entra en ESPERA_5S
— (PRE+1)·125 + 2, a escala real (999.999+1)·125 = 125.000.000 = 5,00 s justos;
racha sobre EXTENDIDO → ESPERA_3S y auto-recolección tras 753 flancos
((PRE+1)·75 + 3) — la TB distingue ambas cuentas y detectaría usar la de 5 s aquí;
segunda ESPERA_5S completa desde cero (los contadores se limpian al salir: sin restos);
amaino dentro de ESPERA_5S → reanuda la extensión al vencer la cuenta completa;
amaino dentro de ESPERA_3S → vuelve a EXTENDIDO sin pasar por EXTIENDE (B no
sube en ningún flanco de esa fase); R manual desde EXTENDIDO sube A hasta C; e
A y B nunca simultáneas. La verificación enriquecida de la versión anterior (modelo
físico del cilindro en el testbench, dos escalas PRE=9/99 y 3 mutaciones negativas) no
se ha re-ejecutado contra esta estructura — registrada como pendiente en NOTAS.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL; -- aritmetica de vectores, como en los apuntes
entity Toldo is
generic (
G_PRE_MAX : integer := 999_999; -- pre-escala MOD-1e6 (20 bits); reducirla al simular
G_T5 : integer := 125; -- MOD-125: 1e6 x 125 = 125e6 pulsos = 5 s
G_T3 : integer := 75 -- MOD-75 : 1e6 x 75 = 75e6 pulsos = 3 s
);
port (
clk, reset : in std_logic;
E, R, V, C, D : in std_logic; -- pulsadores, anemometro, finales de carrera
A, B : out std_logic -- cilindro: A recoge, B extiende (literal del enunciado)
);
end entity Toldo;
architecture ASM of Toldo is
-- nombres de estado = nombres de los 7 bloques del diagrama ASM
type mis_estados is (RECOGIDO, EXTIENDE, ESPERA_5S, EXTENDIDO,
ESPERA_3S, RECOGE, RECOGE_AUTO);
signal estado : mis_estados;
-- CTR5 (temporizador de 5 s, modulo del enunciado: INICIO al entrar en ESPERA_5S,
-- FIN_CUENTA al terminar) y CTR3 (3 s): pre-escala MOD-1e6 en vector de 20 bits
-- (999.999 < 1.048.575; la comparacion es por IGUALDAD, no suma+1: sin overflow)
constant pre_bit : integer := 20;
signal pre5 : std_logic_vector(pre_bit-1 downto 0);
signal tick5 : std_logic_vector(7 downto 0); -- MOD-125: 7 bits; 8 por holgura
signal t5 : std_logic;
signal pre3 : std_logic_vector(pre_bit-1 downto 0);
signal tick3 : std_logic_vector(7 downto 0); -- MOD-75
signal t3 : std_logic;
begin
------- proceso secuencial UNICO: contadores (CTRx) + estado + salidas -------
process
begin
wait until clk = '1';
if reset = '1' then
estado <= RECOGIDO;
A <= '0'; B <= '0';
pre5 <= (others => '0'); tick5 <= (others => '0'); t5 <= '0';
pre3 <= (others => '0'); tick3 <= (others => '0'); t3 <= '0';
else
------- CTR5: corre solo en ESPERA_5S; se limpia al salir -------
if estado /= ESPERA_5S then
pre5 <= (others => '0'); tick5 <= (others => '0'); t5 <= '0';
elsif pre5 = G_PRE_MAX then
pre5 <= (others => '0');
if tick5 = G_T5 - 1 then t5 <= '1'; -- FIN_CUENTA_5s
else tick5 <= tick5 + 1;
end if;
else
pre5 <= pre5 + 1;
end if;
------- CTR3: corre solo en ESPERA_3S; se limpia al salir -------
if estado /= ESPERA_3S then
pre3 <= (others => '0'); tick3 <= (others => '0'); t3 <= '0';
elsif pre3 = G_PRE_MAX then
pre3 <= (others => '0');
if tick3 = G_T3 - 1 then t3 <= '1'; -- FIN_CUENTA_3s
else tick3 <= tick3 + 1;
end if;
else
pre3 <= pre3 + 1;
end if;
------- el ASM: salidas del cilindro dentro de cada estado -------
case estado is
when RECOGIDO => -- toldo guardado: espera de orden
A <= '0'; B <= '0';
if E = '1' and V = '0' then
estado <= EXTIENDE; -- E solo vale en ausencia de viento
end if;
when EXTIENDE => -- B=1 mientras se extiende
A <= '0'; B <= '1';
if D = '1' then estado <= EXTENDIDO; -- prioridad D
elsif V = '1' then estado <= ESPERA_5S; -- racha: PARAR (B=0)
end if;
when ESPERA_5S => -- parado; cuenta iniciada al entrar
A <= '0'; B <= '0'; -- el toldo se PARA: ni recoge ni sale
if t5 = '1' then
if V = '1' then estado <= RECOGE_AUTO; -- sigue la racha: recoger
else estado <= EXTIENDE; -- amaino: seguir extendiendo
end if;
end if;
when EXTENDIDO => -- totalmente extendido, sin salidas
A <= '0'; B <= '0';
if R = '1' then estado <= RECOGE; -- recogida manual
elsif V = '1' then estado <= ESPERA_3S; -- racha sobre extendido
end if;
when ESPERA_3S => -- cuenta iniciada al entrar
A <= '0'; B <= '0';
if t3 = '1' then
if V = '1' then estado <= RECOGE_AUTO; -- sigue la racha: recoger
else estado <= EXTENDIDO; -- no sigue: permanecer
end if;
end if;
when RECOGE | RECOGE_AUTO => -- A=1 hasta el final de carrera C
B <= '0'; A <= '1';
if C = '1' then estado <= RECOGIDO;
end if;
when others =>
estado <= RECOGIDO; A <= '0'; B <= '0';
end case;
end if;
end process;
end architecture ASM;
Notas para el examen: en el examen escribe las constantes directamente
(if pre5 = 999_999, if tick5 = 124, if tick3 = 74) — o déjalas como generic si
piensas instanciar con cuentas reducidas para simular (parametrización del Tema 3,
págs. 33–34). El reset síncrono es obligatorio en la traducción de Tema 3 (aunque el
enunciado no lo nombre): durante reset=1 el estado es RECOGIDO y A=B=0. Estructura
clase: UN proceso secuencial con wait until clk='1' en el que los contadores de los
módulos CTR5/CTR3 del enunciado corren habilitados solo en su estado (y se limpian al
salir) y las salidas del cilindro se escriben dentro de la rama de cada estado; los
nombres de los estados = nombres de los bloques ASM.
Errores típicos — P1
- No escribir los cálculos 125.000.000 y 75.000.000 y su descomposición MOD-10⁶ × MOD-125 / MOD-75: son parte del apartado a y el 5 y el 3 no se reparten igual.
- Olvidar la re-comprobación de V tras la cuenta y recoger siempre, o no recoger nunca: el enunciado condiciona la acción al valor de V al terminar los 5 s / 3 s.
- Usar UNA sola cuenta para las dos rachas, o iniciar la cuenta cuando amaina el viento: se cuenta desde la detección.
- No parar el cilindro en ESPERA_5S (mantener B=1 durante los 5 s): "se debe parar el toldo" exige A=B=0 en ese estado.
- Tratar V como pulso y poner bloqueos de flanco: es nivel mantenido.
- Un único contador compartido para los dos estados sin limpiar entre cuentas: al entrar
en la segunda racha arrancaría con restos de la anterior. Limpieza por
estado /= X. - Invertir A y B (asumir que A suena a «extender»): el enunciado dice «A y B … provocan la recogida y la salida del émbolo, respectivamente» → A recoge, B extiende.
- Estados llamados E0, E1…: los nombres deben coincidir con los bloques del ASM (y el P2 se referencia a ellos).
- Proceso combinacional sin valores por defecto (latches) o
caseincompleto.
Problema 2 — El mismo toldo con PicoBlaze + CTR5/CTR3 (3 puntos)
El enunciado pide dos entregas en el P2: el diagrama lógico detallado y la programación en ensamblador comentada, equivalente a los primeros 7 bloques ASM del apartado 1a) del mismo examen. El programa es un bucle continuo de sondeo de puertos: en este examen no hay ninguna interrupción (la pata INTERRUPT del núcleo y el vector H"3FF" quedan sin usar). La guía GUIA-examen-junio-2023.md sí usó interrupción en su caso B: allí un único frente de sensor saltaba por la pata INTERRUPT y se volvía con RETI; aquí ningún sensor "avisa" al micro: los pulsadores E y R, el anemómetro V y los finales C y D se leen consultando el puerto H"00", y el anemómetro no da un suceso instantáneo sino un nivel mantenido que el bucle comprueba cada vez que haga falta.
Advertencia sobre el enunciado: el enunciado impreso describe la semántica del toldo con nombre de señales (E/R pulsadores, V anemómetro, C/D finales de carrera) y define los bloques temporizadores CTR5/CTR3 con sus entradas por flanco. Esta guía respeta exactamente ese mapa de señales del enunciado y la convención de la asignatura para los problemas de microcontrolador: programa plano con etiquetas y saltos por bandera, sin tablas de estados nuevas — la máquina de estados es la del diagrama ASM del P1, y cada bloque ASM del P1 se traslada 1 a 1 a un bloque del ensamblador. Las direcciones de puertos del bloque de E/S de la FPGA (H"00"–H"03" con PORT_ID de 2 bits) son la convención que fija la hoja de conexiones del problema (IN_PORT_ID/OUT_PORT_ID).
Enunciado (transcripción fiel de la hoja del examen)

- (3,5 puntos) Se desea automatizar el funcionamiento del toldo cuya vista lateral se muestra en la figura. Para ello se han instalado los siguientes elementos: - Dos pulsadores E (extender) y R (recoger) que proporcionan niveles altos al ser accionados por el usuario. - Un anemómetro cuya salida V adopta un nivel alto mientras la velocidad del viento supera un determinado valor. - Un cilindro con dos líneas de control A y B que provocan la recogida y la salida del émbolo, respectivamente, mientras se esté aplicando a las mismas un nivel alto. - Dos finales de carrera C y D que adoptan niveles altos cuando el émbolo del cilindro está totalmente recogido y totalmente extendido, respectivamente. - Un reloj de impulsos de 25 MHz de frecuencia.
El modo de funcionamiento del toldo debe ser el siguiente: - Al poner en marcha el sistema el toldo se encontrará ya recogido. - Si estando el toldo recogido y en ausencia de viento, se activa el pulsador E, éste comenzará a extenderse, y lo hará totalmente si antes no se produce ninguna incidencia. - Si, estando el toldo extendido se activa el pulsador R, éste se recogerá totalmente. - En cualquier momento, si mientras el toldo se está extendiendo se detecta una racha de viento, se debe parar el toldo. El sistema esperará 5 segundos, comprobará si sigue la racha de viento y, en caso de que ésta se mantenga, entonces el toldo se recogerá automáticamente por completo. Si no hay viento ya, el toldo seguirá extendiéndose. - En cualquier momento, si mientras el toldo está totalmente extendido se detecta una racha de viento el sistema esperará 3 segundos, comprobará si sigue la racha de viento y, en caso de que ésta se mantenga, entonces el toldo se recogerá automáticamente por completo. Si no sigue el viento, el toldo permanecerá extendido.
Se pide: a) Diagrama ASM de control. b) VHDL.
- (3 puntos) Diseñar un sistema basado en el microcontrolador PicoBlaze que permita resolver el circuito anterior. Se dispone de: un módulo contador CTR5 que cuenta 5 segundos (RESET: pulso positivo 0->1->0 pone a cero; INICIO_5s: flanco de bajada empieza la cuenta; FIN_CUENTA_5s: ALTO cuando acaba la cuenta, BAJO automáticamente al resetear el módulo); y un módulo contador CTR3 que cuenta 3 segundos con idéntica estructura (RESET, INICIO_3s por bajada, FIN_CUENTA_3s). Se pide: el diagrama lógico detallado (1 punto) y la programación en ensamblador comentada equivalente a los primeros 7 bloques ASM obtenidos en el apartado "a" del problema 1 (2 puntos).
Datos del ejercicio (lo que hay que extraer del enunciado antes de programar)
- E y R son pulsadores (nivel alto mientras se mantienen pulsados), V es el anemómetro (nivel alto mientras dura la racha) y C y D son finales de carrera (nivel cuando el émbolo está en el extremo). Todos se consultan por nivel: el programa decide mirando el bit, y el viento es una señal de nivel mantenido, no un pulso suelto: el bucle de sondeo lo ve siempre.
- La máquina es la del ASM del P1 (7 bloques: RECOGIDO, EXTIENDE, ESPERA_5S, EXTENDIDO, ESPERA_3S, RECOGE, RECOGE_AUTO): cada bloque ASM se convierte en un bloque de ensamblador con su etiqueta, con el mismo orden de comprobaciones — la conversión 1 a 1 es lo que el examen puntúa.
- Los bloques CTR5/CTR3 son dados y su control es delicado (el corazón del problema):
RESET: pulso positivo 0→1→0 pone el contador a cero (hay que subirlo y bajarlo: con RESET alto el módulo no queda operativo).INICIO_x: el arranque es en el flanco de bajada (subir y luego bajar INICIO: la cuenta arranca al bajar).FIN_CUENTA_x: ALTO cuando acaba la cuenta (no durante), y BAJO automáticamente al resetear. Así que la espera del fin es "saltar mientras FIN=0":TEST bit+JUMP Z,etiqueta_de_espera.- Orden de limpieza: el pulso de RESET de un contador SIEMPRE antes de lanzar su INICIO en el mismo bloque (el ASM del P1 limpia la cuenta anterior al entrar en ESPERA_5S: por eso el programa escribe
H"02"→H"00"(pulso RESET_5) y despuésH"01"→H"00"(arranque limpio): al revés, la cuenta arrancaría con un contador a medias de la racha anterior). - Y al acabar la espera de FIN, re-lectura de V: el enunciado exige "comprobará si sigue la racha" al acabar los 5 o 3 segundos: tras FIN hay que volver a leer el puerto de sensores y probar V de nuevo. No hacerlo es el error más frecuente (decidir con el V que se vio antes de la espera).
- Tras FIN, si la racha persiste, el toldo se recoge del todo (RECOGE_AUTO, hasta C); si amainó, retoma la acción que estaba haciendo (extender si estábamos en ESPERA_5S; permanecer extendido si estábamos en ESPERA_3S).
- Las salidas de escritura van a latchs de la lógica de E/S: lo escrito queda retenido entre escrituras — se escribe y ya vale (apagar el toldo = escribir H"00" en H"01" una vez).
- Mapa de puertos (fijado por la hoja de conexiones:
IN_PORT_ID [1..0]/OUT_PORT_ID [1..0]: cuatro puertos): lectura H"00" y H"03"; escritura H"01" y H"02".
P_ENT EQU H"00" ! lectura: bit0=E, bit1=R, bit2=V, bit3=C, bit4=D
P_SAL EQU H"01" ! escritura: bit0=B (extiende), bit1=A (recoge) — A/B según el literal del enunciado: A recoge, B saca
P_CTL EQU H"02" ! escritura: bit0=INICIO_5s, bit1=RESET_5s, bit2=INICIO_3s, bit3=RESET_3s
P_FIN EQU H"03" ! lectura: bit0=FIN_CUENTA_5s, bit1=FIN_CUENTA_3s
Máscaras derivadas: E=H"01", R=H"02", V=H"04", C=H"08", D=H"10"; FIN_5s=H"01", FIN_3s=H"02"; B=H"01" (extiende), A=H"02" (recoge); INICIO_5s=H"01", RESET_5s=H"02", INICIO_3s=H"04", RESET_3s=H"08".
Pasos previos comunes a cualquier programa de este examen
1. Tabla de direcciones y bits (conviene dejarla escrita en la hoja antes del programa; el resto depende de ella):
P_ENT EQU H"00" P_SAL EQU H"01" P_CTL EQU H"02" P_FIN EQU H"03"
Las EQU fijan los ids de puerto; cualquier desplazamiento equivocado arruina el programa: las máscaras de los TEST y los valores de los LOAD de escritura se derivan de este mapa.
2. Registros: en PicoBlaze los registros se escriben s0..sF (s solo con dígito hexadecimal; s10 no es registro). El programa usa pocos: s0 para el dato de sensores, s1 para los valores de control de CTR y s2 para los fines de cuenta (y en algunos tramos el mismo s1 para el cilindro). La tabla del examen los escribe sX,sY (dos registros) o sX,k (un registro + un inmediato).
3. Saltos y flags (del propio enunciado: "Unicos mnemonicos validos: los de la tabla"): la condición de salto va tras la coma: JUMP etiq, JUMP Z,etiq, JUMP NZ,etiq, JUMP C,etiq, JUMP NC,etiq. Z se saca del AND oculto de TEST (o de la resta oculta de COMP); el salto se ejecuta si la condición se cumple: tras TEST s0,H"01" el JUMP Z,... salta si el bit E no está (AND dio 0) y el JUMP NZ,... si sí está. Cuidado con el orden de las comprobaciones: entre un TEST y su JUMP no puede ir ninguna instrucción que afecte a los flags (LOAD, OUT e IN no afectan — la tabla dice "Ninguno").
4. Vectores de interrupción: el ejercicio no pide ninguna interrupción; el programa arranca en H"000" (ORG H"000") y el H"3FF" queda libre para el vector, que aquí no se usa ni se rellena.
El problema se divide en dos partes
| Parte | Qué hay que entregar |
|---|---|
| (a) 1 punto | El diagrama lógico detallado: el núcleo KCPSM3 con su ROM de programa (1024×18), el reloj y reset comunes, y la lógica de E/S de la FPGA (mux de lectura con comparadores para H"00"/H"03" y dos latchs de escritura con comparadores para H"01"/H"02", seleccionados por PORT_ID y las strobes), con los bloques dados CTR5/CTR3 conectados a sus líneas. |
| (b) 2 puntos | La programación en ensamblador comentada, equivalente a los 7 bloques ASM del P1: sondeo de E, R, V, C, D; lanzamiento/limpieza de los temporizadores con el orden correcto de pulso RESET y flanco INICIO; y las esperas de FIN con re-lectura de V. |
Diagrama hardware del Problema 2

Qué ver en el diagrama (la parte de hardware del examen, apartado "diagrama lógico detallado"): el bloque del núcleo impreso en la hoja saca clk, reset, IN_PORT, OUT_PORT, IN_PORT_ID, OUT_PORT_ID, las dos strobes e INTERRUPT/INTERRUPT_ACK (marcadas en rojo: sin usar). El núcleo KCPSM3 necesita la ROM de programa de 1024×18 (ADDRESS[9:0] e INSTRUCTION[17:0]) que el modelo del tema conecta al núcleo — el bloque impreso no saca esos buses, igual que en la guía de junio-2023. La lógica beige de E/S hace de mux de lectura (comparadores H"00"/H"03") y de dos latchs de escritura (comparadores H"01"/H"02" con AND sobre la strobe), seleccionados por PORT_ID; los bloques morados son los dos temporizadores dados, con sus reglas de flanco escritas; el bloque azul es el proceso controlado (cilindro+toldo), que realimenta E, R, V, C y D al bus de entrada, y sus finales y los FIN de los CTR al puerto H"03". Los pies recuerdan las tres ideas: el temporizador corre con el clk (ninguna instrucción del programa depende del tiempo real), las salidas son latchs, y no hay interrupciones: todo sondeo.
Apartados 1 y 2: los bloques temporizadores dados y por qué se controlan por flancos
La hoja da CTR5 y CTR3 como elementos ya construidos ("se dispone de los módulos"). Lo que el examen espera es que el programa los maneje correctamente — cómo se limpia, cómo se lanza una cuenta y cómo se sabe cuándo acaba:
RESET (pulso POSITIVO 0->1->0): pone el contador a cero; FIN_CUENTA baja
automaticamente al resetear. Un RESET que se queda alto deja el
modulo bloqueado: hace falta el frente de bajada del pulso.
INICIO_x (flanco de BAJADA): empieza la cuenta. Mantener INICIO alto no
lanza nada: el arranque es EN el frente de bajada.
FIN_CUENTA_x: ALTO al ACABAR la cuenta (no durante); BAJO al resetear.
Por eso el programa usa siempre la misma secuencia de cuatro escrituras al puerto H"02" (limpiar primero, lanzar después):
H"02" (RESET_5s=1) -> H"00" (RESET_5s=0: pulso positivo completo, CTR5 a cero)
H"01" (INICIO_5s=1) -> H"00" (INICIO_5s=0: frente de BAJADA: arranca la cuenta)
Y con CTR3, la misma con H"08"→H"00" (pulso RESET_3) y H"04"→H"00" (arranque). Dos razones de la forma por flanco: si INICIO se mantuviera alto, el bloque no arrancaría nunca (el arranque es en la bajada) y cada bajada posterior lanzaría una cuenta de más; y el pulso de RESET antes del INICIO garantiza que la cuenta que se lanza está limpia (empezaría con el contador a medias si no se hubiera reseteado: el enunciado pide "esperará 5 segundos" justos). FIN es nivel, no pulso: el programa puede consultarlo cuantas veces haga falta, y se limpia solo al resetear el módulo.
Apartado 3: la tabla de instrucciones del examen (impresa en la hoja)

La hoja del examen trae la tabla de instrucciones impresa en la propia hoja. Para esta guía la hemos auditado recortando la imagen nativa incrustada en el PDF del examen y ampliando cada celda al triple en dos pasadas independientes; el resultado íntegro es esta tabla, que además es la tabla oficial del KCPSM:
| Instrucción | Operando | Flags | Descripción |
|---|---|---|---|
ADD sX,sY / ADD sX,k |
sX,sY / sX,k | Z, C | sX ← sX + sY o sX + k. La anterior CY no se suma |
ADDC sX,sY / ADDC sX,k |
sX,sY / sX,k | Z, C | suma de 9 bits: añade la CY anterior |
SUB sX,sY / SUB sX,k |
sX,sY / sX,k | Z, C | resta con CY=paridad de lo restado (sin préstamo) |
SUBC sX,sY / SUBC sX,k |
sX,sY / sX,k | Z, C | resta de 9 bits con CY=préstamo |
SL sX / SL0 sX / SLA sX |
sX | Z, C | shift izquierdo; SL0 rellena 0; SLA rellena por A[7] |
SR sX / SR1 sX / SR0 sX / SRA sX |
sX | Z, C | shift derecho; SR0 rellena 0; SR1 rellena 1; SRA rellena por A[7] |
RL sX / RR sX |
sX | Z, C | gira a la izq/der por A[7] |
AND sX,sY / AND sX,k |
sX,sY / sX,k | Z, C | Z=1 si el AND da cero; C=paridad del resultado |
OR sX,sY / OR sX,k |
sX,sY / sX,k | Z, C | OR, ídem flags |
XOR sX,sY / XOR sX,k |
sX,sY / sX,k | Z, C | XOR, ídem flags |
COMP sX,sY / COMP sX,k |
sX,sY / sX,k | Z, C | resta sin guardar; Z=1 si son iguales; C=1 si sX<sY |
TEST sX,sY / TEST sX,k |
sX,sY / sX,k | Z, C | AND sin guardar resultado: Z=1 si el AND da 0; no cambia sX |
LOAD sX,sY / LOAD sX,k |
sX,sY / sX,k | Ninguno | copia |
IN sX,sY / IN sX,k |
sX,sY / sX,k | Ninguno | lee el puerto; con k usa el k como id de puerto |
OUT sX,sY / OUT sX,k |
sX,sY / sX,k | Ninguno | escribe el puerto: sX=datos, sY o k=id de puerto |
FETCH / STORE |
— | Ninguno | RAM de 64 (x8) en serie, con puntero |
JUMP etiq |
— | Ninguno | salto |
JUMP etiq,Z/NZ/C/NC |
— | leen Z/C | salto condicionado: si la condición se cumple |
CALL etiq |
— | Ninguno | pila de 3 niveles (aquí no hace falta) |
RET |
— | Ninguno | volver (la tabla dice RET, no RETURN) |
EINT / DINT |
— | Ninguno | habilitan/deshabilitan la interrupción (sin usar aquí) |
RETI |
— | Ninguno | volver de interrupción (sin usar aquí) |
Detalles útiles: TEST s0, H"04" (un registro y un inmediato) y TEST s0, s1 (dos registros) son las dos sintaxis de la misma instrucción; la solución usa la primera: aislar un bit del dato leído y decidir por bandera sin alterar el registro consultado. Los operandos de IN/OUT son sX,(sY) o sX,kk: con el id de puerto dado como inmediato (IN s0, P_ENT con P_ENT EQU H"00" equivale a IN s0, H"00"). El ensamblador del examen traduce los EQU a k. Fuera de la tabla no hay nada: CONSTANT, RETURN, BRANCH, JP, INPUT, OUTPUT y condiciones CC/CS no son mnemónicos de esta tabla: en el examen, escribirlos es un error. La solución solo usa LOAD, IN, OUT, TEST y JUMP (etiq, Z y NZ).
Apartado 4: programa del microcontrolador (equivalente 1 a 1 a los 7 bloques ASM)
Cada bloque del diagrama ASM del P1 se traslada a un bloque del ensamblador con su etiqueta, con el mismo orden de comprobaciones (primero la condición de salida del bloque, después las incidencias):
ASM 1 RECOGIDO -> INICIO (espera E pulsado sin viento; deja A=B=0)
ASM 2 EXTIENDE -> EXTIENDE/EXT_BUC (B=1; comprueba D primero, luego V)
ASM 3 ESPERA_5S -> PARO_5S/F5_BUC (para el toldo, limpia/lanza CTR5,
espera FIN_5 y re-lee V)
ASM 4 EXTENDIDO -> EXTENDIDO/EXT_BUC2 (sin salidas; comprueba R primero,
luego V)
ASM 5 ESPERA_3S -> PARO_3S/F3_BUC (limpia/lanza CTR3, espera FIN_3
y re-lee V: el cilindro no se mueve)
ASM 6 RECOGE -> RECOGE/C_BUC (A=1 hasta C)
ASM 7 RECOGE_AUTO -> RECOGE_AUTO/C2_BUC (A=1 hasta C)
;=====================================================================
; Toldo (junio-2024, Problema 2): PicoBlaze + contadores CTR5/CTR3
; Ensamblador equivalente a los bloques ASM 1-7 del Problema 1a.
; Unicos mnemonicos validos: los de la tabla impresa en el examen.
; Aqui se usan LOAD, IN, OUT, TEST y JUMP (etiq, Z y NZ).
;
; Puerto lectura H"00": bit0=E bit1=R bit2=V bit3=C bit4=D
; Puerto escritura H"01": bit0=B (extender) bit1=A (recoger) — literal: A recoge, B saca
; Puerto escritura H"02": bit0=INICIO_5s bit1=RESET_5s
; bit2=INICIO_3s bit3=RESET_3s
; Puerto lectura H"03": bit0=FIN_CUENTA_5s bit1=FIN_CUENTA_3s
;=====================================================================
P_ENT EQU H"00" ; sensores (E, R, V, C, D)
P_SAL EQU H"01" ; lineas A y B del cilindro
P_CTL EQU H"02" ; lineas de control de CTR5 y CTR3
P_FIN EQU H"03" ; salidas FIN_CUENTA de los contadores
ORG H"000"
; ---------------------------------------------------------------------
; BLOQUE ASM 1: RECOGIDO (estado inicial, toldo guardado, sin salidas)
; ---------------------------------------------------------------------
INICIO: LOAD s1, H"00" ; mascara A=0, B=0: cilindro sin accionar
OUT s1, P_SAL ; aseguramos el parado al arrancar
IN s0, P_ENT ; leo E, R, V, C, D en un solo byte
TEST s0, H"01" ; pruebo E (bit0): Z=1 mientras E este a 0
JUMP Z, INICIO ; E=0: sigo esperando en RECOGIDO
TEST s0, H"04" ; E=1: pruebo V (bit2): ?hay viento?
JUMP NZ, INICIO ; con viento NO se extiende: sigo en RECOGIDO
; ---------------------------------------------------------------------
; BLOQUE ASM 2: EXTIENDE (B=1 mientras se extiende)
; ---------------------------------------------------------------------
EXTIENDE:
LOAD s1, H"01" ; B=1, A=0: el cilindro saca el embolo
OUT s1, P_SAL
EXT_BUC:
IN s0, P_ENT ; compruebo final de carrera y viento
TEST s0, H"10" ; pruebo D (bit4): Z=1 mientras no llegue
JUMP NZ, EXTENDIDO ; D=1: extension completa -> BLOQUE 4
TEST s0, H"04" ; ?racha DURANTE la extension?
JUMP NZ, PARO_5S ; racha: -> BLOQUE 3 (parar + cuenta 5 s)
JUMP EXT_BUC ; ni D ni viento: sigo extendiendo
; ---------------------------------------------------------------------
; BLOQUE ASM 3: ESPERA_5S (toldo parado; CTR5 arranca y se sondea FIN)
; ---------------------------------------------------------------------
PARO_5S:
LOAD s1, H"00" ; A=0, B=0: PARO el toldo (lo exige el
OUT s1, P_SAL ; enunciado: "se debe parar el toldo")
LOAD s1, H"02" ; RESET_5s a 1 ...
OUT s1, P_CTL ;
LOAD s1, H"00" ; ... y a 0: pulso POSITIVO 0->1->0 que pone
OUT s1, P_CTL ; CTR5 a cero (FIN_5 baja automaticamente)
LOAD s1, H"01" ; INICIO_5s a 1 ...
OUT s1, P_CTL ;
LOAD s1, H"00" ; ... y a 0: FLANCO DE BAJADA = arranca la
OUT s1, P_CTL ; cuenta de 5 s del modulo CTR5
F5_BUC: IN s2, P_FIN ; espero el fin de cuenta por sondeo
TEST s2, H"01" ; pruebo FIN_CUENTA_5s (bit0)
JUMP Z, F5_BUC ; aun no vale 1: sigo en el bucle
IN s0, P_ENT ; RE-COMPRUEBO V al acabar los 5 s (el ASM
TEST s0, H"04" ; lo exige: "comprobará si sigue la racha")
JUMP NZ, RECOGE_AUTO ; sigue la racha -> BLOQUE 7: recoger del todo
JUMP EXTIENDE ; amainó el viento -> BLOQUE 2: sigo extendiendo
; ---------------------------------------------------------------------
; BLOQUE ASM 4: EXTENDIDO (totalmente extendido, sin salidas)
; ---------------------------------------------------------------------
EXTENDIDO:
LOAD s1, H"00" ; sin salidas: el cilindro ya no actua
OUT s1, P_SAL
EXT_BUC2:
IN s0, P_ENT ; miro R y V
TEST s0, H"02" ; pruebo R (bit1): orden manual de recoger
JUMP NZ, RECOGE ; R=1 -> BLOQUE 6
TEST s0, H"04" ; ?racha con el toldo ya totalmente extendido?
JUMP NZ, PARO_3S ; -> BLOQUE 5 (cuenta de 3 s)
JUMP EXT_BUC2 ; permanezco extendido
; ---------------------------------------------------------------------
; BLOQUE ASM 5: ESPERA_3S (aqui el toldo no se mueve: solo CTR3)
; ---------------------------------------------------------------------
PARO_3S:
LOAD s1, H"08" ; RESET_3s a 1 ...
OUT s1, P_CTL ;
LOAD s1, H"00" ; ... y a 0: pulso POSITIVO: CTR3 a cero,
OUT s1, P_CTL ; FIN_3 baja automaticamente
LOAD s1, H"04" ; INICIO_3s a 1 ...
OUT s1, P_CTL ;
LOAD s1, H"00" ; ... y a 0: FLANCO DE BAJADA = arranca la
OUT s1, P_CTL ; cuenta de 3 s del modulo CTR3
F3_BUC: IN s2, P_FIN ; espero el fin de cuenta por sondeo
TEST s2, H"02" ; pruebo FIN_CUENTA_3s (bit1)
JUMP Z, F3_BUC ; aun no vale 1: bucle
IN s0, P_ENT ; re-comprobacion de V al acabar los 3 s
TEST s0, H"04" ; ?sigue la racha?
JUMP NZ, RECOGE_AUTO ; persiste -> BLOQUE 7: recoger del todo
JUMP EXTENDIDO ; no persiste -> BLOQUE 4: permanecer extendido
; ---------------------------------------------------------------------
; BLOQUE ASM 6: RECOGE (manual: A=1 hasta el final de carrera C)
; ---------------------------------------------------------------------
RECOGE:
LOAD s1, H"02" ; A=1, B=0: el cilindro recoge
OUT s1, P_SAL
C_BUC: IN s0, P_ENT ; espero la llegada del final de carrera C
TEST s0, H"08" ; pruebo C (bit3): totalmente recogido
JUMP Z, C_BUC ; mientras C=0: sigo recogiendo
LOAD s1, H"00" ; llego a C: apago el cilindro
OUT s1, P_SAL
JUMP INICIO ; -> BLOQUE 1 (RECOGIDO)
; ---------------------------------------------------------------------
; BLOQUE ASM 7: RECOGE_AUTO (recogida automatica por racha)
; ---------------------------------------------------------------------
RECOGE_AUTO:
LOAD s1, H"02" ; A=1: recogida automatica
OUT s1, P_SAL
C2_BUC: IN s0, P_ENT
TEST s0, H"08" ; pruebo C (bit3)
JUMP Z, C2_BUC ; hasta el final de carrera
LOAD s1, H"00" ; llego a C: apago el cilindro
OUT s1, P_SAL
JUMP INICIO ; -> BLOQUE 1 (RECOGIDO)
;=====================================================================
; Nota: en RECOGE y RECOGE_AUTO no hace falta mirar el viento: recoger
; ya es la accion segura; y en RECOGIDO una pulsacion de E con V=1 se
; descarta en el propio sondeo (TEST H"04" + JUMP NZ, INICIO).
;=====================================================================
Qué hace cada bloque, línea a línea
BLOQUE ASM 1 — RECOGIDO: lee, y solo extiende con E pulsado y sin viento
INICIO: LOAD s1, H"00" ; #1 A=0, B=0
OUT s1, P_SAL ; #2 parado asegurado al arrancar
IN s0, P_ENT ; #3 un solo byte con E,R,V,C,D
TEST s0, H"01" ; #4 pruebo E
JUMP Z, INICIO ; #5 sin E: espero
TEST s0, H"04" ; #6 pruebo V
JUMP NZ, INICIO ; #7 viento: NO se extiende
| # | instrucción | qué hace | dónde se apoya |
|---|---|---|---|
| 1–2 | LOAD+OUT al puerto H"01" |
asegura el parado del cilindro al arrancar (el latch queda en H"00") | salidas latch: escribir y mantener |
| 3–5 | IN+TEST H"01"+JUMP Z |
espera la pulsación de E (por nivel) | mapa: E=bit0; TEST no altera s0 |
| 6–7 | TEST H"04"+JUMP NZ |
descarta la extensión con viento presente | enunciado: "recogido y en ausencia de viento" |
Con E pulsado y V=0 cae al bloque 2 sin ninguna escritura intermedia: el propio OUT s1,H"00" de la línea #2 es el que mantiene el cilindro apagado mientras no se pulse nada.
BLOQUE ASM 2 — EXTIENDE: B=1 con doble comprobación (D primero, racha después)
LOAD s1, H"01" ; #1 B=1: el cilindro saca el émbolo
OUT s1, P_SAL
EXT_BUC:IN s0, P_ENT ; #2 sondeo
TEST s0, H"10" ; #3 pruebo D
JUMP NZ, EXTENDIDO ; #4 D=1: llegué
TEST s0, H"04" ; #5 pruebo V
JUMP NZ, PARO_5S ; #6 racha: parar + cuenta de 5 s
JUMP EXT_BUC ; #7 ni D ni viento: sigo
El orden D→V es el del diagrama ASM (la salida del bloque es D, y la incidencia es la racha): si D y racha llegaran a la vez, gana D (extensión completada antes de la incidencia). La condición de racha dispara la parada con temporización de 5 s.
BLOQUE ASM 3 — ESPERA_5S: parada del toldo, limpieza+arranque de CTR5, espera de FIN_5 y re-lectura de V
PARO_5S:LOAD s1, H"00" ; #1-2 PARO el toldo (A=B=0: "se debe parar")
LOAD s1, H"02" ; #3-4 RESET_5s: pulso positivo 0->1->0
OUT s1, P_CTL ; (FIN_5 baja automaticamente)
LOAD s1, H"00"
LOAD s1, H"01" ; #5-6 INICIO_5s: subida
OUT s1, P_CTL
LOAD s1, H"00" ; #7-8 INICIO_5s: BAJADA = arranca la cuenta
OUT s1, P_CTL
F5_BUC: IN s2, P_FIN ; #9-11 espera de FIN por sondeo
TEST s2, H"01"
JUMP Z, F5_BUC ; mientras FIN_5=0
IN s0, P_ENT ; #12-14 RE-LECTURA de V al acabar la cuenta
TEST s0, H"04"
JUMP NZ, RECOGE_AUTO ; persiste: recoger del todo
JUMP EXTIENDE ; amainó: retomar la extensión
| # | instrucción | qué hace | dónde se apoya |
|---|---|---|---|
| 1–2 | OUT H"00" a P_SAL |
para el toldo exigida por el enunciado | "se debe parar el toldo" |
| 3–6 | cuatro LOAD/OUT a P_CTL |
pulso RESET completo y después el flanco de arranque | apartados 1–2: orden limpieza→arranque |
| 9–11 | IN P_FIN+TEST H"01"+JUMP Z |
espera "mientras FIN_5=0"; sale cuando FIN=1 | enunciado: FIN ALTO al ACABAR |
| 12–14 | IN+TEST+dos JUMP |
re-lectura de V: decide racha→RECOGE_AUTO / amainó→EXTIENDE | enunciado: "comprobará si sigue la racha" |
La escritura #7–#8 (bajada de INICIO_5s) es la que lanza la cuenta: el programa mantiene el puerto de control en H"00" al terminar, así que INICIO queda en 0 y el único frente de bajada es el lanzado deliberadamente (no hay bajada "sueltas" posteriores que reboten en lanzar cuentas nuevas).
BLOQUE ASM 4 — EXTENDIDO: sin salidas, comprueba R primero y luego la racha de 3 s
EXTENDIDO escribe H"00" en P_SAL (el cilindro ya no actúa: el émbolo ya está en D) y EXT_BUC2 sondea: TEST H"02"+JUMP NZ,RECOGE (R manual tiene prioridad: es la acción pedida por el usuario) y TEST H"04"+JUMP NZ,PARO_3S (racha → cuenta de 3 s). Si nada: JUMP EXT_BUC2 (permanezco extendido).
BLOQUE ASM 5 — ESPERA_3S: solo CTR3, el cilindro no se mueve
Igual que ESPERA_5S con las máscaras de CTR3 (pulso H"08"→H"00", arranque H"04"→H"00"), espera F3_BUC con TEST H"02"+JUMP Z y re-lectura de V: persiste → RECOGE_AUTO; no persiste → EXTENDIDO. En este bloque no se escribe nada en P_SAL: el enunciado solo exige "esperar 3 s y comprobar" en un toldo ya parado.
BLOQUES ASM 6/7 — RECOGE y RECOGE_AUTO: A=1 hasta C
RECOGE (manual desde R) y RECOGE_AUTO (por racha persistente tras 5 s o 3 s) son idénticos en estructura: B=1 en P_SAL, bucle TEST H"08"+JUMP Z esperando C, y al llegar C escribir H"00" y volver a INICIO. En ellos no se vigila el viento: recoger es la acción segura pedida (el enunciado: "se recogerá automáticamente por completo", y la manual "se recogerá totalmente").
Apartado 5: el programa comprobado con un mini-emulador
El programa de arriba se ha verificado ejecutándolo en un mini-emulador en Python del propio PicoBlaze: ensambla la hoja y simula el entorno físico real (el cilindro se mueve paso a paso con A/B hasta C/D; E, R son pulsadores de ventana, V es una racha de viento con ventana de inicio y fin, y los bloques CTR5/CTR3 cumplen exactamente las reglas del enunciado: pulso RESET positivo que borra con FIN bajando solo, arranque en flanco de bajada, FIN ALTO al acabar). El emulador solo acepta los mnemónicos de la tabla impresa: escribe ERROR ante CONSTANT, RETURN, BRANCH, JP, INPUT, OUTPUT, condiciones CC/CS o registros fuera de s0..sF (así se detectan de inmediato los errores de tabla en un examen).
Resultados de la simulación (salida real del emulador): programa ensamblado: 71 instrucciones; escenario A: racha de viento durante la extensión → el programa para el toldo, CTR5 lanza su cuenta y al acabar la cuenta, con la racha persistiendo, el toldo se recoge automáticamente; escenario B: la racha amaina durante los 5 s → el programa retoma la extensión (y una segunda racha posterior vuelve a lanzar la cuenta: prueba de que la limpieza con pulso RESET dejó el bloque operativo, con FIN limpio); escenario C: pulsación de R desde extendido → recogida manual hasta C sin usar ningún temporizador; escenario D: racha con el toldo extendido → CTR3 lanza la cuenta de 3 s y, si persiste, recogida automática; escenario E: racha de 3 s que amaina → permanece extendido (el toldo no se movió) y una pulsación de R posterior sí lo recoge. Además, 7 variantes negativas (injetando cada una un bug concreto en el ensamblador — p. ej. saltarse el OUT del pulso RESET, no apagar el toldo en PARO_5S, usar H"08" en vez de H"04" para INICIO_3s, o invertir el TEST de V en RECOGIDO —) caen las 7 en los asserts del emulador, con motivo concreto de fallo: el test detecta exactamente el bug inyectado. Las correcciones que había que pillar para que el programa pasara: escribir s0/s1/s2 (no s10), RET (no RETURN), EQU solo como directriz, los ids de puerto como inmediato de IN/OUT, el pulso RESET antes del INICIO en los bloques de espera, la re-lectura de V tras FIN, y la dirección del JUMP de espera (salta mientras FIN=0, no al revés).
Correcciones que hay que vigilar en los apartados escritos a mano
- El
TESTno modifica el dato consultado: decir que "el TEST borra el bit probado" o "deja s0 a 0" es incorrecto — Z se saca del AND en secreto y sX queda intacto. - El
JUMPde espera de FIN va al revés de lo que parece natural: FIN está ALTO solo al acabar la cuenta, así que se salta mientras FIN=0 (JUMP Z,etiq_de_espera). Un bucleJUMP NZmientras FIN=1 sería un bucle que se sale de inmediato (FIN todavía no ha subido nunca: el error más grave del ejercicio, porque el programa se saltaría la temporización entera). - El pulso de RESET hay que completarlo (subida y bajada:
H"02"→H"00"): con RESET alto el módulo queda bloqueado y la cuenta siguiente no existe. Y el orden es siempre RESET (limpieza) antes de INICIO (arranque): al revés, la cuenta arrancaría con restos de la anterior. - El arranque es en el flanco de bajada de INICIO:
H"01"→H"00"; mantener INICIO alto no lanza nada. Escribir INICIO=1 y dejarlo alto es quedarse sin cuenta. - Falta la re-lectura de V tras FIN: el enunciado exige "comprobará si sigue la racha" al acabar los 5 o los 3 segundos: hay que volver a
IN s0,P_ENTyTEST H"04"antes de decidir RECOGE_AUTO/EXTIENDE (o EXTENDIDO). Decidir con el V visto antes de la espera es error de concepto. - En ESPERA_5S el enunciado exige parar el toldo (
OUT H"00"a P_SAL antes de lanzar CTR5): si el toldo sigue extendiéndose durante la cuenta de 5 s, la acción contraria posterior se solaparía con la marcha; en ESPERA_3S no hay nada que parar (el cilindro ya estaba apagado en EXTENDIDO). - En RECOGIDO, la extensión solo es válida con ausencia de viento (
TEST H"04"+JUMP NZ,INICIOtras E): lanzar la extensión con viento contradice el enunciado. - En RECOGE y RECOGE_AUTO no hace falta vigilar el viento: recoger es la acción segura; y en RECOGIDO una pulsación de E con V=1 se descarta en el propio sondeo.
- Las salidas son latch: escribir H"00" en H"01" tras H"01" no "apaga el toldo para el futuro", cambia el estado presente del latch. Para mantener, se escribe una vez y ya.
- No hay
CALL/RET/RETI/EINTen la solución: estructura plana con etiquetas yJUMP; la pila y las interrupciones no se usan en este problema.ORG H"000"yENDson directrices, no instrucciones: no salen en la tabla.
Apartados de temas que se pueden preguntar (con la dirección exacta de las diapositivas)
Cada apartado va con la dirección exacta de la diapositiva del PDF del tema donde está el contenido (una por apartado; no vale citar "el tema" a secas). Las páginas se citan por el número impreso del PDF (1-based), como en las guías de junio-2022 y junio-2023.
Apartado: "explica por qué la comprobación de la racha de viento se hace por sondeo y no por interrupción"
La comprobación de un nivel que puede cambiar en cualquier momento con un micro que sondea no requiere capturas de flanco: el anemómetro mantiene V alta mientras dura la racha, y el
TEST+JUMPdel bucle ve el nivel siempre presente. Una interrupción solo haría falta para un suceso instantáneo que pueda ocurrir entre dos sondeos: la pata INTERRUPT, su ACK y elRETIexisten en el núcleo, pero este ejercicio prescinde de ellas y el vector H"3FF" queda libre. Lo contrario (el caso B de junio-2023) sí usaba interrupción: allí el sensor daba un único frente que el micro no podía perderse entre sondeos.
PDF del tema: Tema 4 — Tema 4 SD-II_20220512.pdf, página 30 (diapositiva del esquema del PicoBlaze con las patas del bloque, incluidas INTERRUPT/INTERRUPT_ACK, y el modelo de "dos módulos": núcleo KCPSM6 + ROM de programa), y página 11 (la introducción del concepto de firmware embebido: el PicoBlaze como núcleo de firmware embebido dentro de la FPGA).
Apartado: "¿por qué los bloques CTR5/CTR3 se controlan con pulso en RESET y con flanco de bajada en INICIO?"
Porque una entrada de arranque mantenida a nivel no lanza ninguna cuenta: el bloque lanza con el frente, y un RESET que queda alto deja el módulo bloqueado. El control con latchs de escritura permite escribir y olvidarse: el latch retiene la última escritura, y el programa termina siempre con el puerto de control en H"00" para que no haya bajadas sueltas que reboten en arranques no deseados.
PDF del tema: Tema 4, páginas 34 y 35 (la tabla de instrucciones impresa en el propio tema: LOAD sin flags; TEST/COMP que solo afectan a Z y C — el patrón TEST+salto de este programa es el de esas diapositivas).
Apartado: "el mapa de direcciones de puertos: ¿cómo decide la FPGA qué puerto se lee o escribe?"
El núcleo emite PORT_ID (2 bits: hasta 4 puertos) junto a la strobe del ciclo; la lógica de E/S compara PORT_ID con la dirección de cada puerto y activa el mux de lectura o el latch de escritura correspondiente. El
OUT sX,kde la tabla pone en el bus los datos sX y el id k; el bloque traduce ese id a PORT_ID y WRITE_STROBE en el ciclo del puerto.
PDF del tema: Tema 4, página 37 (el ciclo de instrucción del PicoBlaze: memoria de programa de 1024 palabras y el vector de interrupción en la última posición), y página 38 (la tabla de saltos condicionados de la tabla impresa: JUMP etiq y JUMP etiq,Z/NZ/C/NC).
Apartado: "¿cuántas posiciones de memoria tiene la ROM del programa?"
1024 (ADDRESS[9:0]) de palabra de 18 bits: el programa de este ejercicio son 71 instrucciones: sobra sitio con muchísimo.
PDF del tema: Tema 4, página 45 (la diapositiva donde el tema fija el número de posiciones y el ancho de palabra de la memoria de programa del PicoBlaze, y el uso de la última posición como vector).
Cifras del examen (dónde sale cada cuenta)
- La ROM del núcleo es de 1024 posiciones (ADDRESS[9:0]) de palabra de 18 bits: el tema lo fija en la p. 45 y el diagrama lo rotula; el programa son 71 instrucciones de 1024.
- 4 puertos con 2 bits de PORT_ID (H"00"–H"03"): el mapa de la hoja de conexiones. Los 4 bits de control de H"02" cubren exactamente los dos bloques (2 bits por bloque: INICIO_5s, RESET_5s, INICIO_3s, RESET_3s).
- 5 s y 3 s los cuentan CTR5 y CTR3 con el clk de 25 MHz: no hay que calcular ningún divisor — los bloques vienen dados y el programa solo lanza pulsos y flancos; ninguna instrucción del programa depende del tiempo real (el bucle de sondeo puede tardar lo que tarde: el temporizador corre en el bloque, no en el bucle).
- 5 bits de entrada de sensores usados de 8 (E, R, V, C, D) y 2 bits de fines en H"03"; 2 bits (A, B) + 4 bits de control de salida.
Problema 3 — CPU von Neumann: microoperaciones, UC y codificación (3,5 puntos)

Planteamiento. La Unidad de Procesado transfiere datos por un bus interior
de 8 bits: la línea ENx de un registro lo conecta al bus (alta impedancia si
no está habilitada) y la línea Cx lo carga desde el bus (números exactos de la
figura: RT=EN2/C2, MARL=EN3/C3, MARH=EN4/C4, PCH=EN5/C5, PCL=EN6/C6, IR=EN7/C7,
AC=EN8/C8, MDR=EN9 con modo C10C9, SUBH=EN11/C12, SUBL=EN10/C11). El ciclo de
carga y decodificación es idéntico para todas las instrucciones (PC→MAR,
lectura de memoria→MDR, MDR→IR) y ocupa los 4 primeros micro-pasos; la ejecución
varía: las instrucciones de 2 bytes leen el dato en el paso siguiente y las de
dirección de 16 bits la montan byte a byte (primero la parte ALTA, luego la
BAJA, como fija el enunciado) usando RT como puente. La figura nativa (pág. 3
del PDF) muestra tres cableados que condonan el plan: R de la ALU es una
salida directa de RT (no hay registro R cargable), la salida de la ALU
solo escribe AC (no hay camino ALU→bus) y MDR está visible con su modo
C10C9 hacia el bus externo DB (D7–D0). Por eso MUL3 (×3) se hace con RT←AC y
dos sumas encadenadas con RT fijo en R, y ADD fija el dato en RT. El micro-
programa completo son 55 microinstrucciones → MPC de 6 bits, palabra de
control de 24 bits: de ahí salen las codificaciones binarias que piden.
📚 Teoría: Tema 5, págs. 4–6 del PDF — la microinstrucción se divide en campo de selección de condiciones, campo de direcciones de salto y campo de señales de control; y los componentes MPC, multiplexor de condiciones y memoria de control (ROM).
Baremo del enunciado: a) microoperaciones por instrucción + separación carga/decodificación vs ejecución: 2,25 p · b) UC multiplexor–contador–memoria y conexión a la UO: 0,75 p · c) codificación binaria de las 6 primeras microinstrucciones: 0,5 p.
Líneas de control dadas + supuestos (decláralos en el examen)
| C1 C0 | ALU | C14 C13 | PC | C10 C9 | MDR | ||
|---|---|---|---|---|---|---|---|
| 00 | L+R | 01 | incrementa PCH+PCL | 01 | carga del bus externo y entrada hacia el interior | ||
| 01 | L−R | 10 | resetea PCH+PCL | 10 | carga del bus interior y salida hacia el exterior | ||
| 10 | L | ||||||
| 11 | R+1 |
Supuestos (escríbelos): la figura no rotula cargas para L ni C: L es transparente (toma el valor del bus en el ciclo de operación ALU) y la salida de la ALU se captura en AC al activarse el código C1C0 (00/01/11); con C1C0=10 inactivo, AC se carga del bus con su C8. Existe un flag Z (caja Z en la figura) que vale 1 cuando el resultado de la última operación ALU es 0 (condición de JUMP Z). Escribir en la memoria externa requiere MDR configurado como salida (C10C9=10) más un pulso de escritura WE̅ de la CPU (el dibujo no lo rotula; decláralo). La pareja C11/C12·EN10/EN11 del par SUBH/SUBL se declara SUBH=C12/EN11, SUBL=C11/EN10. El bus interior admite una sola fuente ENx por micro-paso; la lectura/escritura externa (DB↔MDR) y el incremento del PC no usan el bus interior y sí pueden ir en paralelo con una transferencia interna. La dirección de 16 bits llega en dos bytes consecutivos: primero la ALTA, luego la BAJA (lo fija el enunciado).
a) Microoperaciones — ciclo de carga y decodificación común (T0–T3)
| Paso | Micro-operación | Señales de control |
|---|---|---|
| T0 | MARH ← PCH | EN5, C4 |
| T1 | MARL ← PCL | EN6, C3 |
| T2 | MDR ← M[MAR] y en paralelo PC ← PC+1 | C10C9=01; C14C13=01 |
| T3 | IR ← MDR (decodificación; el opcode va además a CONTROL) | EN9, C7; MPC ← vector(IR) |
Tras T2 el PC apunta ya al byte siguiente. Contabilidad de incrementos: instrucción de 1 byte → PC suma 1 (T2); de 2 bytes → 2 (T2+E2); de 3 bytes → 3 (T2, E2 y E5). Todo lo que sigue de cada instrucción es ciclo de ejecución.
Secuencias de ejecución por instrucción (EJECUCIÓN)
(1) LDAC $dir (00001000) — 3 bytes. AC ← M[$dir]. Ejecución (10 micro-op.):
| Paso | Micro-operación | Control |
|---|---|---|
| E0 | MARH ← PCH (PC apunta a la parte alta de $dir) | EN5, C4 |
| E1 | MARL ← PCL | EN6, C3 |
| E2 | MDR ← M[MAR] (byte ALTO de $dir); PC ← PC+1 | C10C9=01; C14C13=01 |
| E3 | RT ← MDR (guardo la parte alta) | EN9, C2 |
| E4 | MARL ← PCL (posición del byte BAJA; MARH sigue valiendo) | EN6, C3 |
| E5 | MDR ← M[MAR] (byte BAJA); PC ← PC+1 (ya apunta a la sig. instr.) | C10C9=01; C14C13=01 |
| E6 | MARH ← RT | EN2, C4 |
| E7 | MARL ← MDR → MAR = $dir completo | EN9, C3 |
| E8 | MDR ← M[MAR] (leo el dato; NO suma PC: los 3 incrementos van en T2, E2, E5) | C10C9=01 |
| E9 | AC ← MDR | EN9, C8 |
(2) ADD (dato) (00001001) — 2 bytes. AC ← AC + dato (actualiza Z).
Ejecución (5): E0 MARH←PCH (EN5,C4) · E1 MARL←PCL (EN6,C3) · E2 MDR←M[MAR] con
el dato, PC+1 · E3 RT ← MDR (EN9,C2: RT fija la entrada R directamente) ·
E4 AC ← L+R con C1C0=00 y EN8 en el bus (L = valor actual de AC; R = RT =
dato); Z ← (resultado=0).
(3) MUL3 (00001010) — 1 byte. AC ← 3×AC (actualiza Z). La ALU no
multiplica: ×3 = (AC+AC)+AC. RT guarda un operando fijo en R y L toma el valor
del bus en cada suma. Ejecución (3):
E0 RT ← AC (EN8,C2) · E1 AC ← L+R (C1C0=00; EN8 da L=A, R=RT=A) →
AC = 2A · E2 AC ← L+R (C1C0=00; EN8 da L=2A, R=RT=A) → AC = 3A; Z←(=0).
⚠ Con esta figura no existe RT ← salida ALU (la ALU solo escribe AC) ni
registro R cargable: el borrador clásico «L←AC, R←AC, RT←C, R←RT» es
imposible. Una sola suma con L=R=AC daría 2×AC, no 3×AC. C1C0=11 (R+1) no
sirve para multiplicar. PC ya está completo tras T2 (1 byte).
(4) SUBR $dir (00001011) — 3 bytes. SUB ← PC (retorno); PC ← $dir.
Ejecución (10): E0–E2 como LDAC (MAR←PC, lee byte ALTO, PC+1) · E3 RT←MDR ·
E4 MARL←PCL · E5 MDR←M[MAR] (byte BAJA); PC←PC+1 → PC = instrucción
siguiente (retorno) · E6 SUBH←PCH (EN5,C12) · E7 SUBL←PCL (EN6,C11) →
SUB = dirección de retorno · E8 PCH←RT (EN2,C5) · E9 PCL←MDR (EN9,C6) →
PC = $dir.
(5) RETS (00001100) — 1 byte. PC ← SUB. Ejecución (2):
E0 PCH←SUBH (EN11,C5) · E1 PCL←SUBL (EN10,C6). El +1 del fetch sobre el opcode
de RETS queda destruido por la carga: correcto.
(6) JUMP Z $dir (00001101) — 3 bytes. Salta a $dir si la última operación ALU dio 0. No se toca la ALU en la ejecución para no destruir Z. Ejecución (10): E0–E5 idénticos al montaje LDAC (RT=alta, MDR=baja, PC+1 en E2 y E5 → PC = opcode+3, efecto «no salto») · E6 decisión sobre Z (micro-paso sin señales; en la UC: MPC ← A+Z): Z=0 → paso nulo E7' → fetch siguiente; Z=1 → E7 PCH←RT (EN2,C5) · E8 PCL←MDR (EN9,C6) → PC = $dir.
(7) STAC $dir (00001110) — 3 bytes. M[$dir] ← AC. Ejecución (10):
E0–E7 como LDAC hasta MAR = $dir · E8 MDR ← AC con C10C9=10 y EN8 (bus
interior → MDR, configurado como salida al exterior) · E9 M[MAR]←MDR (pulso
WE̅ a la memoria).
(8) STOP (00001111) — 1 byte. Tras el fetch (T0–T3) el microprograma entra en un bucle sin señales (MPC auto-saltándose): unidad operativa inactiva hasta reset. No genera ningún incremento (el +1 de T2 del fetch es común a todo fetch y queda inutilizado).
Verificación: estas 8 secuencias se codificaron como el microprograma de la
tabla siguiente y se ejecutaron en un modelo Python de la unidad de procesado
(con la regla de un solo driver ENx por ciclo, MAR completo antes de cada
acceso a memoria e IR cargado siempre desde MDR) con el programa LDAC $2000
(dato 07H) · ADD 5 · MUL3 · SUBR $3000 (ADD 1; RETS) · STAC $0040 · JUMP Z
$5000 · STOP: AC = 07H → 0CH → 24H → (subr) 25H, SUB = 0009H, tras RETS
PC = 0009H, M[0040H] = 25H, JUMP Z no tomado (el último ALU, ADD 1, dejó
Z=0), PC final 0010H. Segundo test con ADD FB (AC=05+FB=00 → Z=1) y subrutina
vacía: MUL3(0)=0 mantiene Z=1 y JUMP Z tomado → PC = 5000H y STOP en 5000H
deja PC final 5001H. Todos los PC intermedios exactos.
b) Unidad de control: multiplexor – memoria de control – contador (0,75 p)
📚 Teoría: Tema 5, pág. 9 del PDF — «Diseño de la unidad de control (I)»: el tamaño de la memoria de control lo condiciona el tamaño del microprograma y la palabra debe contener el campo de selección de condiciones, el de direcciones de salto y el de señales de control.
Componentes y conexión (dibujar):
┌────────────────────────────────────────────────────┐
│ MUX 5:1 de siguiente dirección (campo SEL) │
│ 000: MPC+1 011: vector(IR) ← mini-ROM │
│ 001: A+Z (salto 010: A (salto abs./STOP) │
│ condicional) 100: 000000 (fin: fetch) │
└───────────────┬────────────────────────────────────┘
▼ carga paralela / cuenta
reset ──► MPC (contador 6 bits) ──► MC (ROM/PLA 64 palabras × 24 bits) ──► CMBR
CMBR: campos SRC/DEST ──► descodificador SRC→ENx; descodificador DEST→Cx;
C1C0→ALU; C10C9→MDR; C14C13→PC; WE→pulso WE̅ a la memoria externa
CMBR: SEL y A ──► MUX anterior; IR(3:0) ──► mini-ROM vector (opcode→dirección);
Z (flag ALU) ──► suma A+Z; reset ──► MPC←0
- MPC: contador de 6 bits (55 microinstrucciones ≤ 64) con carga paralela y reset.
- MC: memoria de control, 64 palabras de 24 bits direccionadas por MPC (ROM o PLA).
- CMBR: registro buffer de la microinstrucción (24 bits) que paraleliza los campos.
- Conexión con la unidad operativa: el campo SRC pasa por un descodificador que genera las líneas ENx (una sola activa por ciclo); el campo DEST genera las señales de carga Cx; C1C0/C10C9/C14C13/WE van directas a ALU, MDR, PC y memoria (con C1C0 activo, la captura ALU→AC sustituye la carga C8). Entradas externas de la UC: IR(3:0) → mini-ROM vector (la línea IR→CONTROL está en la figura), y Z → suma A+Z del salto condicional.
Mapa del microprograma (55 microinstrucciones, direcciones MC):
| Instrucción | opcode | Dirección MC | Micro-op. ejecución |
|---|---|---|---|
| Fetch (T0–T3) | — | 00H–03H | — (común) |
| LDAC | 08H | 04H–0DH | 10 |
| ADD | 09H | 0EH–12H | 5 |
| MUL3 | 0AH | 13H–15H | 3 |
| SUBR | 0BH | 16H–1FH | 10 |
| RETS | 0CH | 20H–21H | 2 |
| JUMP Z | 0DH | 22H–2BH | 8 + decisión + paso nulo |
| STAC | 0EH | 2CH–35H | 10 |
| STOP | 0FH | 36H (bucle SEL=010, A=36H) | 0 |
Vector código→dirección (mini-ROM 16×6 indexada por IR(3:0), usada en SEL=011
de la micro 03H): 08H→04H, 09H→0EH, 0AH→13H, 0BH→16H, 0CH→20H, 0DH→22H,
0EH→2CH, 0FH→36H (códigos 00H–07H no definidos: pueden dirigir a 36H como si
fueran STOP).
Tabla completa de microinstrucciones (cada fila es un ciclo del modelo
ejecutado; -- = campo inactivo; la columna EN es la fuente al bus interior y
la columna C la carga desde el bus):
| MC | EN (origen) | C (destino) | C1C0 | C10C9 | C14C13 | WE | SEL | A | Acción |
|---|---|---|---|---|---|---|---|---|---|
| 00H | EN5 PCH | C4 MARH | -- | -- | -- | 0 | 000 | -- | MARH←PCH |
| 01H | EN6 PCL | C3 MARL | -- | -- | -- | 0 | 000 | -- | MARL←PCL |
| 02H | -- | -- | -- | 01 | 01 | 0 | 000 | -- | MDR←M[MAR]; PC+1 |
| 03H | EN9 MDR | C7 IR | -- | -- | -- | 0 | 011 | -- | IR←MDR; MPC←vector(IR) |
| 04H | EN5 PCH | C4 MARH | -- | -- | -- | 0 | 000 | -- | LDAC: MARH←PCH |
| 05H | EN6 PCL | C3 MARL | -- | -- | -- | 0 | 000 | -- | MARL←PCL |
| 06H | -- | -- | -- | 01 | 01 | 0 | 000 | -- | lee byte alto $dir; PC+1 |
| 07H | EN9 MDR | C2 RT | -- | -- | -- | 0 | 000 | -- | RT←alta($dir) |
| 08H | EN6 PCL | C3 MARL | -- | -- | -- | 0 | 000 | -- | MARL←PCL |
| 09H | -- | -- | -- | 01 | 01 | 0 | 000 | -- | lee byte bajo; PC+1 |
| 0AH | EN2 RT | C4 MARH | -- | -- | -- | 0 | 000 | -- | MARH←alta |
| 0BH | EN9 MDR | C3 MARL | -- | -- | -- | 0 | 000 | -- | MARL←bajo → MAR=$dir |
| 0CH | -- | -- | -- | 01 | -- | 0 | 000 | -- | MDR←M[$dir] (sin PC+1) |
| 0DH | EN9 MDR | C8 AC | -- | -- | -- | 0 | 100 | -- | AC←MDR; fetch siguiente |
| 0EH | EN5 PCH | C4 MARH | -- | -- | -- | 0 | 000 | -- | ADD: MARH←PCH |
| 0FH | EN6 PCL | C3 MARL | -- | -- | -- | 0 | 000 | -- | MARL←PCL |
| 10H | -- | -- | -- | 01 | 01 | 0 | 000 | -- | MDR←dato; PC+1 |
| 11H | EN9 MDR | C2 RT | -- | -- | -- | 0 | 000 | -- | RT←dato (R=RT directo) |
| 12H | EN8 AC | -- | 00 | -- | -- | 0 | 100 | -- | AC←L+R; Z; fetch |
| 13H | EN8 AC | C2 RT | -- | -- | -- | 0 | 000 | -- | MUL3: RT←AC |
| 14H | EN8 AC | -- | 00 | -- | -- | 0 | 000 | -- | AC←AC+RT=2AC (R=RT fijo) |
| 15H | EN8 AC | -- | 00 | -- | -- | 0 | 100 | -- | AC←AC+RT=3AC; Z; fetch |
| 16H | EN5 PCH | C4 MARH | -- | -- | -- | 0 | 000 | -- | SUBR: MARH←PCH |
| 17H | EN6 PCL | C3 MARL | -- | -- | -- | 0 | 000 | -- | MARL←PCL |
| 18H | -- | -- | -- | 01 | 01 | 0 | 000 | -- | lee byte alto; PC+1 |
| 19H | EN9 MDR | C2 RT | -- | -- | -- | 0 | 000 | -- | RT←alta($dir) |
| 1AH | EN6 PCL | C3 MARL | -- | -- | -- | 0 | 000 | -- | MARL←PCL |
| 1BH | -- | -- | -- | 01 | 01 | 0 | 000 | -- | lee byte bajo; PC+1 (=retorno) |
| 1CH | EN5 PCH | C12 SUBH | -- | -- | -- | 0 | 000 | -- | SUBH←PCH |
| 1DH | EN6 PCL | C11 SUBL | -- | -- | -- | 0 | 000 | -- | SUBL←PCL → SUB=retorno |
| 1EH | EN2 RT | C5 PCH | -- | -- | -- | 0 | 000 | -- | PCH←alta($dir) |
| 1FH | EN9 MDR | C6 PCL | -- | -- | -- | 0 | 100 | -- | PCL←bajo → PC=$dir; fetch |
| 20H | EN11 SUBH | C5 PCH | -- | -- | -- | 0 | 000 | -- | RETS: PCH←SUBH |
| 21H | EN10 SUBL | C6 PCL | -- | -- | -- | 0 | 100 | -- | PCL←SUBL; fetch |
| 22H | EN5 PCH | C4 MARH | -- | -- | -- | 0 | 000 | -- | JZ: MARH←PCH |
| 23H | EN6 PCL | C3 MARL | -- | -- | -- | 0 | 000 | -- | MARL←PCL |
| 24H | -- | -- | -- | 01 | 01 | 0 | 000 | -- | lee byte alto; PC+1 |
| 25H | EN9 MDR | C2 RT | -- | -- | -- | 0 | 000 | -- | RT←alta($dir) |
| 26H | EN6 PCL | C3 MARL | -- | -- | -- | 0 | 000 | -- | MARL←PCL |
| 27H | -- | -- | -- | 01 | 01 | 0 | 000 | -- | lee byte bajo; PC+1 (no salta) |
| 28H | -- | -- | -- | -- | -- | 0 | 001 | 29H | MPC←29H+Z: Z=0→29H · Z=1→2AH |
| 29H | -- | -- | -- | -- | -- | 0 | 100 | -- | Z=0: paso nulo → fetch siguiente |
| 2AH | EN2 RT | C5 PCH | -- | -- | -- | 0 | 000 | -- | Z=1: PCH←alta($dir) |
| 2BH | EN9 MDR | C6 PCL | -- | -- | -- | 0 | 100 | -- | PCL←bajo → PC=$dir; fetch |
| 2CH | EN5 PCH | C4 MARH | -- | -- | -- | 0 | 000 | -- | STAC: MARH←PCH |
| 2DH | EN6 PCL | C3 MARL | -- | -- | -- | 0 | 000 | -- | MARL←PCL |
| 2EH | -- | -- | -- | 01 | 01 | 0 | 000 | -- | lee byte alto; PC+1 |
| 2FH | EN9 MDR | C2 RT | -- | -- | -- | 0 | 000 | -- | RT←alta($dir) |
| 30H | EN6 PCL | C3 MARL | -- | -- | -- | 0 | 000 | -- | MARL←PCL |
| 31H | -- | -- | -- | 01 | 01 | 0 | 000 | -- | lee byte bajo; PC+1 |
| 32H | EN2 RT | C4 MARH | -- | -- | -- | 0 | 000 | -- | MARH←alta |
| 33H | EN9 MDR | C3 MARL | -- | -- | -- | 0 | 000 | -- | MARL←bajo → MAR=$dir |
| 34H | EN8 AC | -- | -- | 10 | -- | 0 | 000 | -- | MDR←AC (bus interior, salida exterior) |
| 35H | -- | -- | -- | -- | -- | 1 | 100 | -- | M[MAR]←MDR (WE̅); fetch |
| 36H | -- | -- | -- | -- | -- | 0 | 010 | 36H | STOP: bucle sin señales |
c) Codificación binaria de las 6 primeras microinstrucciones (0,5 p)
📚 Teoría: Tema 5, págs. 17–18 del PDF — el microprograma simbólico de ejemplo del procesador sencillo arranca igual que este fetch (MAR←PC, IR←M(MAR), PC←PC+1) y luego se codifica en «microprograma binario» posición a posición.
Justificación de anchuras: 55 microinstrucciones ≤ 64 → MPC y campo A de 6 bits. Campos de la palabra de control (CMBR), 24 bits, en el orden de la figura b): señales | condición/salto | control:
| Campo | Bits | Codificación |
|---|---|---|
| SRC | 4 | 0000=bus flotante · 0001=AC (EN8) · 0010=MDR (EN9) · 0011=RT (EN2) · 0100=PCH (EN5) · 0101=PCL (EN6) · 0110=SUBH (EN11) · 0111=SUBL (EN10) |
| DEST | 4 | 0000=ninguna · 0001=AC (C8) · 0010=IR (C7) · 0011=RT (C2) · 0100=PCH (C5) · 0101=PCL (C6) · 0110=MARH (C4) · 0111=MARL (C3) · 1000=SUBH (C12) · 1001=SUBL (C11) |
| C1C0 | 2 | operación ALU; en filas que no la usan se pone 10 (= pasa L), inocuo porque la captura ALU→AC solo ocurre con códigos de operación (00/01/11) |
| C10C9 | 2 | 00 inactivo · 01 lectura externa→MDR · 10 bus interior→MDR hacia memoria |
| C14C13 | 2 | 00 nada · 01 incrementa PC · 10 reset PC |
| WE | 1 | pulso de escritura WE̅ a memoria externa |
| SEL | 3 | 000 MPC+1 · 001 MPC←A+Z · 010 MPC←A · 011 MPC←vector(IR) · 100 MPC←000000 (fetch) |
| A | 6 | dirección de salto (0 si SEL=000/011/100) |
Orden de bits: SRC(4) DEST(4) C1C0(2) C10C9(2) C14C13(2) WE(1) SEL(3) A(6)
= 4+4+2+2+2+1+3+6 = 24 bits. Las 6 primeras microinstrucciones del
microprograma (micro 00H–05H = fetch T0–T3 + los dos primeros pasos del LDAC):
| MC | SRC | DEST | C1C0 | C10C9 | C14C13 | WE | SEL | A | palabra de 24 bits | hex |
|---|---|---|---|---|---|---|---|---|---|---|
| 00H | 0100 | 0110 | 10 | 00 | 00 | 0 | 000 | 000000 | 0100 0110 10 00 00 0 000 000000 |
468000H |
| 01H | 0101 | 0111 | 10 | 00 | 00 | 0 | 000 | 000000 | 0101 0111 10 00 00 0 000 000000 |
578000H |
| 02H | 0000 | 0000 | 10 | 01 | 01 | 0 | 000 | 000000 | 0000 0000 10 01 01 0 000 000000 |
009400H |
| 03H | 0010 | 0010 | 10 | 00 | 00 | 0 | 011 | 000000 | 0010 0010 10 00 00 0 011 000000 |
2280C0H |
| 04H | 0100 | 0110 | 10 | 00 | 00 | 0 | 000 | 000000 | 0100 0110 10 00 00 0 000 000000 |
468000H |
| 05H | 0101 | 0111 | 10 | 00 | 00 | 0 | 000 | 000000 | 0101 0111 10 00 00 0 000 000000 |
578000H |
Acciones: 00H MARH←PCH · 01H MARL←PCL · 02H MDR←M[MAR] y PC+1 · 03H IR←MDR y MPC←vector(IR) · 04H y 05H son E0/E1 de LDAC (idénticas a 00H/01H). (Si tu mapa del microprograma coloca la decodificación por salto en otro orden, adapta el campo SEL de la micro de decodificación — lo que se comprueba es el dominio del formato, no el orden.)
Verificación: las 6 palabras anteriores las genera y audita automáticamente el modelo Python del microprograma (24 bits exactos cada una; el microprograma completo de 55 filas ejecuta dos programas test sin errores: TRAZADA OK, y 4/4 de las inyecciones de fallo caen: dos ENx a la vez, MAR incompleto, IR sin MDR y WE sin modo salida).
Errores típicos — P3
- No separar claramente el ciclo de carga/decodificación (T0–T3 comunes) del de ejecución: es literalmente lo que pide el enunciado (2,25 p por el desglose).
- Olvidar que la dirección de 16 bits llega en dos bytes (alta primero) y montar MAR en un solo paso: hacen falta 2 lecturas + RT de puente.
- Creer que existe registro R cargable o camino ALU→bus: en la figura R es la salida directa de RT y la ALU solo escribe AC. Por eso ADD fija el dato en RT y MUL3 son RT←AC + dos sumas encadenadas (con una sola suma AC+AC = 2×AC, no 3×AC; y «RT ← resultado ALU» no existe).
- PC+1 de más o de menos: 2 bytes → incrementos en T2 y E2; 3 bytes → el tercero va en la lectura del byte bajo (E5), no al final. Verificado: con un +1 de más el programa se descuadra tras la primera instrucción.
- En SUBR guardar SUB antes del último PC+1: SUB apuntaría al byte bajo del operando en vez de a la instrucción de retorno.
- En JUMP Z usar la ALU antes de la decisión y destruir Z; o decidir «en el aire»: hay que materializarlo con SEL=001 (MPC←A+Z) y reservar un paso nulo para el camino no-tomado.
- Escribir «MDR←AC» a secas en STAC: hacen falta EN8 en el bus, C10C9=10 (salida al exterior) y el pulso WE̅ en un paso distinto.
- Usar dos líneas ENx a la vez en un micro-paso (colisión de bus): cada paso interno admite una sola fuente; la lectura/escritura externa y el PC+1 sí pueden acompañar a una transferencia interna porque no usan el bus interior.
- En la codificación: dejar el campo C1C0 «vacío» (no existe código inactivo: usa 10) o no justificar las anchuras (55 ≤ 64 → 6 bits; palabra 4+4+2+2+2+1+3+6 = 24).
- Dejar SEL de la micro de decodificación en 000: sin SEL=011 (vector IR) no hay salto a la ejecución de cada instrucción.
- No conectar la mini-ROM vector ni la línea Z al MUX de la UC.