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=08 estricto y validado con testbench sobre la versión de estilo de clase (proceso único con wait until y 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)

  1. 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).
  2. 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.
  3. 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
stateDiagram-v2 [*] --> RECOGIDO : arranque RECOGIDO --> EXTIENDE : E=1 y V=0 EXTIENDE --> EXTENDIDO : D=1 EXTIENDE --> ESPERA_5S : V=1 (racha) [PARAR] ESPERA_5S --> RECOGE_AUTO : T5=1 y V=1 ESPERA_5S --> EXTIENDE : T5=1 y V=0 EXTENDIDO --> RECOGE : R=1 EXTENDIDO --> ESPERA_3S : V=1 (racha) ESPERA_3S --> RECOGE_AUTO : T3=1 y V=1 ESPERA_3S --> EXTENDIDO : T3=1 y V=0 RECOGE --> RECOGIDO : C=1 RECOGE_AUTO --> RECOGIDO : C=1

Claves del planteamiento (lo que puntúa):

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


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)

Figura del enunciado (imagen nativa del PDF): el toldo con los pulsadores E/R, el anemómetro V, el cilindro con las líneas A/B y los finales de carrera C/D.
Figura del enunciado (imagen nativa del PDF): el toldo con los pulsadores E/R, el anemómetro V, el cilindro con las líneas A/B y los finales de carrera C/D.
  1. (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.

  1. (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)

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

Bloque «PicoBlaze Microcontroller» impreso en el examen (imagen nativa del PDF): el dibujo no saca los pines ADDRESS/INSTRUCTION; en el modelo del Tema 4 la ROM de programa es el segundo módulo.
Bloque «PicoBlaze Microcontroller» impreso en el examen (imagen nativa del PDF): el dibujo no saca los pines ADDRESS/INSTRUCTION; en el modelo del Tema 4 la ROM de programa es el segundo módulo.

Diagrama hardware del control del toldo: PicoBlaze KCPSM3 + CTR5/CTR3 clk: 25 MHz (el del sistema) reset: inicializa (PC=0) KCPSM3 (firmware core PicoBlaze) embebido dentro de la FPGA 16 registros s0-sF + ALU control: genera PORT_ID y strobes pila hardware de 3 niveles RAM scratchpad: sin uso aqui IN_PORT/OUT_PORT + PORT_ID + strobes INTERRUPT y INTERRUPT_ACK: sin usar clk reset ADDRESS instr. de 18b ROM de programa 1024 x 18 block RAM de la FPGA (WE a 0) 000H-3FEH: programa (71 de 1024) ADDRESS[9:0] = 2^10 = 1024 INSTRUCTION[17:0]: palabra de 18b 3FFH: vector de interrupcion sin usar (el programa no usa EINT) el bloque impreso en el examen no saca ADDRESS/INSTRUCTION: en el modelo del tema la ROM es el 2o modulo Logica de E/S en la FPGA (fuera del nucleo) el puerto se elige comparando PORT_ID con la strobe del ciclo pulsadores E,R y anemometro V FIN de CTR5 y CTR3 = H"00" = H"03" MUX 2:1 IN_PORT[7:0] READ_STROBE + PORT_ID PORT_ID WRITE_STROBE = H"01" (port_id) AND latch salidas H"01": B (bit0) y A (bit1) = H"02" (port_id) AND latch control H"02": CTR5/CTR3 bits 0 y 1 bits 2 y 3 modulo CTR5 (dado) RESET: pulso 0->1->0; FIN baja INICIO_5s: flanco de bajada arranca FIN_CUENTA_5s: alto al acabar modulo CTR3 (dado) RESET: pulso 0->1->0; FIN baja INICIO_3s: flanco de bajada arranca FIN_CUENTA_3s: alto al acabar proceso: cilindro + toldo lineas A y B del cilindro E, R, V, C, D del enunciado A, B FIN de los CTR -> H"03" E, R, V, C, D del proceso realimentan el puerto H"00" CTR5 y CTR3 cuentan los 5 s y los 3 s con el clk de 25 MHz: el programa solo genera los flancos de control y sondea FIN el micro sondea pulsadores y anemometro con IN + TEST + JUMP Z; las salidas A, B y los flancos de control quedan retenidos en los latches INTERRUPT, INTERRUPT_ACK y el vector 3FFH quedan sin usar: todo el control es por sondeo de puertos

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)

Tabla de instrucciones impresa en el propio examen: la única ISA válida del problema (auditoríaía visual en dos pasadas por bandas ampliadas al triple; sin RETURN ni CONSTANT; RET y EINT/DINT/RETI presentes).
Tabla de instrucciones impresa en el propio examen: la única ISA válida del problema (auditoríaía visual en dos pasadas por bandas ampliadas al triple; sin RETURN ni CONSTANT; RET y EINT/DINT/RETI presentes).

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

  1. El TEST no 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.
  2. El JUMP de 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 bucle JUMP NZ mientras 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).
  3. 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.
  4. 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.
  5. 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_ENT y TEST H"04" antes de decidir RECOGE_AUTO/EXTIENDE (o EXTENDIDO). Decidir con el V visto antes de la espera es error de concepto.
  6. 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).
  7. En RECOGIDO, la extensión solo es válida con ausencia de viento (TEST H"04"+JUMP NZ,INICIO tras E): lanzar la extensión con viento contradice el enunciado.
  8. 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.
  9. 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.
  10. No hay CALL/RET/RETI/EINT en la solución: estructura plana con etiquetas y JUMP; la pila y las interrupciones no se usan en este problema. ORG H"000" y END son 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+JUMP del 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 el RETI existen 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,k de 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)


Problema 3 — CPU von Neumann: microoperaciones, UC y codificación (3,5 puntos)

Figura del enunciado (imagen nativa del PDF): la Unidad de Procesado de Datos von Neumann con el bus interior de 8 bits, los pares ENx/Cx y la tabla ALU impresa.
Figura del enunciado (imagen nativa del PDF): la Unidad de Procesado de Datos von Neumann con el bus interior de 8 bits, los pares ENx/Cx y la tabla ALU impresa.

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).

P3 jun24: unidad de procesado von Neumann (bus interior 8 bits) bus interior 8 bits PCH[8] EN5·C5 PCL[8] EN6·C6 IR[8] EN7·C7 SUBH[8] EN11·C12 SUBL[8] EN10·C11 C14C13: 01 suma PC, 10 reset CONTROL UC (apdo. b) opcode IR C0–C14 EN2–EN11 WE̅ MARH[8] EN4·C4 MARL[8] EN3·C3 AB[16] A15–A0 (a Memoria) RT[8] EN2·C2 ALU L ← bus (transparente) R = salida directa de RT C1C0 Z ALU→AC (no pasa por bus) AC[8] EN8·C8 MDR[8] EN9 (salida) · C10C9 (modo) DB[8] D7–D0 (a/de Memoria) todo dato que entra o sale del procesador pasa por MDR MEM ext. (WE̅) Cx: carga desde el bus interior · ENx: salida tri-state al bus C10C9 MDR: 01 lectura externa→MDR · 10 bus interior→MDR→memoria C1C0 ALU: 00 L+R · 01 L−R · 10 L · 11 R+1 (captura en AC)

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

P3 jun24: unidad de control multiplexor–memoria–contador mini-ROM vector (16×6, dir = IR(3:0)) Z (flag de la ALU) MUX 5:1 (campo SEL) 000: MPC+1 · 001: A+Z 010: A · 011: vector(IR) 100: 000000 (fin→fetch) MPC contador (6 bits) cuenta / carga reset→0 MC memoria de control (64×24) dir CMBR (24 bits) SEL, A descodificador SRC → ENx descodificador DEST → Cx C1C0 · C10C9 C14C13 · WE (directas) campos de la microorden UNIDAD OPERATIVA (figura de la derecha): ENx habilitan registros al bus · Cx cargan · ALU, MDR, PC WE̅ a memoria externa · Z del ALU y IR(3:0) entran a la UC

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


Guía de estudio generada a partir de la guía del profesor. Las cifras y códigos están verificados (GHDL / emulador KCPSM6 / barridos de direcciones). Revisa el baremo de cada problema antes del examen.