Guía de resolución — Examen de Sistemas Digitales II, Junio 2023 (01-06-2023)

El examen consta de 3 problemas que suman 10 puntos:

# Puntos Tipo
1 3,0 (ASM 1,5 + VHDL 1,5) Control ASM+VHDL de la cinta de botes de pelotas de tenis (sensor fotoeléctrico S, sensor de bote colocado B, línea de avance Y)
2 3,5 (hardware 1 + ensamblador 2,5) El mismo control con microcontrolador picoBlaze + visualizador de 7 segmentos con el número de pelotas del bote (0–3). El examen imprime el bloque «PicoBlaze Microcontroller» con sus pines y la tabla de instrucciones
3 3,5 (microoperaciones 2,5 + unidad de control 1) Unidad de procesado von Neumann (bus 8/16, registros PC/AC/MAR/IR/Buffer/SAR): microoperaciones de la tabla LDAC/CMAC/ADD/STAC/SUBR/RTN/STOP y unidad de control multiplexor–contador–memoria

Estado de esta guía: 3 de 3 problemas publicados. El P1 lleva ASM de 4 bloques y VHDL al estilo de clase analizado en GHDL 4.1.0 y verificado con testbench (pulsos de duración indeterminada, nivel largo que no debe contar, B por nivel, dos botes completos). El P2 lleva auditoría visual de la tabla de instrucciones y del bloque impresos, diagrama hardware propio y programa verificado con un mini-emulador KCPSM3. El P3 lleva datapath redibujado, secuencia de microoperaciones verificada con un verificador del datapath (TRAZADA OK, 71 ciclos) y unidad de control multiplexor–contador–memoria dimensionada.

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

Problema 1 — Cinta de botes de pelotas: ASM + VHDL (3 puntos)

Figura del enunciado (imagen nativa del PDF): las pelotas caen por el plano inclinado con un sensor fotoeléctrico sobre la entrada del bote, y la cinta con rodillos transporta los botes llenos. El sensor B del asiento no está rotulado en la figura: lo fija solo el texto del enunciado.
Figura del enunciado (imagen nativa del PDF): las pelotas caen por el plano inclinado con un sensor fotoeléctrico sobre la entrada del bote, y la cinta con rodillos transporta los botes llenos. El sensor B del asiento no está rotulado en la figura: lo fija solo el texto del enunciado.

Enunciado (literal de la hoja del examen). «1. (3 puntos) En una fábrica de pelotas de tenis, éstas ruedan por un plano inclinado hasta caer en un bote que está sobre una cinta transportadora. La cinta transportadora debe avanzar (mientras recibe un 1 por la línea 'Y') cuando un bote está lleno (con un total de tres pelotas), para colocar debajo un nuevo bote. Cuando el siguiente bote está situado en su lugar, un sensor B lo indica mediante un nivel alto. Se desea diseñar el sistema de control de la cinta transportadora, sabiendo que cuando cae una pelota se activa (con un nivel alto) un sensor fotoeléctrico S colocado encima de la entrada a la caja, como se muestra en la siguiente figura. Las pelotas caen con el suficiente espacio temporal para que no se solapen los pulsos del sensor S, los cuales pueden durar un número indeterminado de ciclos de reloj. Se pide: Diagrama ASM de control (1,5 puntos). Describir el circuito mediante VHDL (1,5 puntos).»

Datos que fija el enunciado y decisiones de diseño

Fija el enunciado: el proceso (las pelotas ruedan por el plano inclinado y caen en el bote apoyado sobre la cinta; S es el sensor fotoeléctrico colocado encima de la entrada a la caja y adopta nivel alto al pasar cada pelota; la figura lo corrobora: rótulos «Sensor», «Pasa una pelota» y «No pasa nada» sobre la señal S, un pulso alto por pelota); bote lleno = 3 pelotas; la cinta avanza mientras recibe un 1 por Y, es decir Y se MANTIENE en alto desde que el bote se llena hasta que el bote nuevo queda en su sitio; B indica con nivel alto (no es un pulso) que el bote nuevo está colocado; los pulsos de S no se solapan y pueden durar un número indeterminado de ciclos de reloj; y no da ninguna magnitud temporal ni frecuencia: aquí no hay escalas de reloj que calcular — no inventes ni 25 MHz ni temporizadores. Baremo: a) diagrama ASM 1,5 p + b) VHDL 1,5 p = 3,0 p.

No lo fija el enunciado (supuestos de la guía, documentados):

  1. Cada pelota cuenta por el frente de subida de S, no por su nivel. Con pulso de duración indeterminada, contar el nivel sumaría de 1 a N por la misma pelota según cuánto corte el rayo. La transición del ASM se etiqueta «frente de subida de S»: un frente = una pelota. Es el truco del ejercicio (y la diferencia con los finales de carrera del toldo de junio-2024, que sí son niveles).
  2. S es una entrada asíncrona al sistema síncrono: se sincroniza con dos FF (s1, s2) antes de tocar la lógica y una etapa de retardo más (s3); el frente dura un ciclo y vale s2='1' and s3='0'. Supuesto: el pulso de S dura al menos un ciclo de reloj (lo dice el enunciado: «número indeterminado de ciclos»).
  3. Cuatro estados con nombre (VACIO, UNA, DOS, LLENO) y contador separado NO. El contenido del bote (0–3) queda codificado en el propio estado: con solo cuatro valores un contador de 2 bits duplicaría la máquina, y el Tema 3 evalúa la tabla de transiciones del ASM (un bloque por estado). El contador explícito sí compensa en el P2 de este mismo examen, que tiene que visualizar el número de pelotas en 7 segmentos.
  4. Una pelota que cayera mientras la cinta avanza (estado LLENO, antes de B) no se cuenta: LLENO solo sale por B, y el flanco de la pelota que llenó el bote no puede recontarse porque el frente dura un ciclo. El enunciado da espacio temporal suficiente entre pelotas y el avance de la cinta es corto: si aun así cayera, esa pelota iría al bote retirado y no figuraría en el nuevo — límite del diseño, documentado aquí (criterio idéntico al del P2 de este examen).
  5. rst asíncrono obligatorio en el VHDL (el ASM no lo pide; lo añade la traducción de Tema 3): figura en la lista de sensibilidad (process (clk, rst)) y su rama if rst = '1' va delante del elsif rising_edge(clk). Mientras vale 1 el registro está en VACIO y Y=0 (cinta parada), y lo hace sin esperar a ningún flanco de reloj (actúa a nivel).

Planteamiento. El control es una ASM con un estado por contenido posible del bote: VACIO, UNA, DOS y LLENO. Cada frente de subida de S (detección en el VHDL porque el pulso dura un número indeterminado de ciclos) sube el contenido un escalón, y LLENO es el único estado con Y=1, mantenido hasta que B confirma con su nivel que el bote nuevo está en su sitio, momento en que se vuelve a VACIO con el contaje a cero. La figura del examen (raster nativo figuras/jun23/recortes/figura-p1-cinta-nativa.jpg) sitúa el sensor fotoeléctrico en la línea encima de la entrada a la caja y dibuja la forma de onda de S; B no aparece rotulado en la figura: lo define solo el texto.

a) Diagrama ASM — 4 bloques (1,5 p)

Bloques ASM (uno por estado; entre corchetes la salida activa del estado; sin transición = permanecer):

# Bloque ASM (estado) Salida Decisiones → siguiente estado
1 VACIO (arranque, 0 pelotas) — frente de subida de S → UNA
2 UNA (1 pelota) — frente de subida de S → DOS
3 DOS (2 pelotas) — frente de subida de S → LLENO (3ª pelota: lleno)
4 LLENO (3 pelotas) Y=1 (cinta en marcha) B=0: quedarse (la cinta sigue avanzando) · B=1 → VACIO
stateDiagram-v2 [*] --> VACIO : arranque / reset VACIO --> UNA : frente de S (pelota 1) UNA --> DOS : frente de S (pelota 2) DOS --> LLENO : frente de S (pelota 3, bote lleno) [Y sube] LLENO --> VACIO : B=1 (bote nuevo en su sitio) [Y cae]

Claves del planteamiento (lo que puntúa):

Ejemplo de recorrido: VACIO →(pelota 1, pulso 3 ciclos) UNA →(pelota 2, pulso 7 ciclos) DOS →(pelota 3, pulso 2 ciclos) LLENO[Y=1, cinta avanzando] →(bote nuevo, B=1 nivel) VACIO, y la pelota siguiente vuelve a contar desde 0.

📚 Teoría: Tema 3, págs. 15–19 del PDF «Tema 3 SD-II_20200413.pdf» — cajas de estado, selección y condición; el bloque ASM es lo que hay entre dos cajas de estado. 📚 Teoría: Tema 3, págs. 26–28 del PDF «Tema 3 SD-II_20200413.pdf» — ejemplo antirrebote: actuar una sola vez por pulsación, esperar el rearme.

b) Descripción VHDL del ASM (1,5 p)

📚 Teoría: Tema 3, págs. 23–24 del PDF «Tema 3 SD-II_20200413.pdf» — diagrama ASM y módulo VHDL equivalente, el uno junto al otro. 📚 Teoría: Tema 3, págs. 30–32 del PDF «Tema 3 SD-II_20200413.pdf» — traducción de ASM a VHDL: como diagrama de estados, añadiendo reloj y reset a los puertos de la tarjeta identificativa.

Analizado con GHDL 4.1.0 (--std=08) y verificado con un testbench que lanza las pelotas como niveles de duración indeterminada y coteja Y con asserts severity failure: reset (cinta parada); bote 1 con pulsos de 3, 7 y 2 ciclos (Y NO sube con dos pelotas y sube con la tercera); B mantenido en alto varios ciclos (la cinta se para al confirmarse y no vuelve a arrancar sola mientras B sigue alto); Y se muestrea durante varios ciclos seguidos en cada lleno (la orden de avanzar DURA mientras B=0); una pelota larga de 12 ciclos seguidos (vale UNA pelota, no doce: Y sigue en 0) y bote 2 completado con nivel largo + 9 + 1; reset asíncrono a mitad de periodo: con Y=1, rst se activa sin flanco y Y cae 5 ns después —sin ningún flanco de reloj—; una pelota cuya subida empezó bajo rst vale exactamente UNA pelota al rearmarse el sincronizador, y el contaje re-arranca desde cero; contaje global de subidas de Y (exactamente 3 en toda la sesión). Resultado: TEST PASSED. Además se re-ejecutó la batería de tres mutaciones de la verificación rica (que antes estaba pendiente contra la estructura nueva): contar el nivel de S en vez del frente cae a los 1710 ns («Y subió con 2 pelotas»), apagar Y por cuenta propia sin esperar a B cae a los 6110 ns («la cinta dejó de avanzar»), y no volver a VACIO al confirmar B cae a los 2410 ns («cinta no se paró con B=1»). Las tres caen con simulation failed.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity Cinta is
    port (
        clk, rst     : in  std_logic;
        S, B         : in  std_logic;   -- fotoelectricos S (pelota) y B (bote colocado)
        Y            : out std_logic    -- cinta: avanza mientras Y=1
    );
end entity Cinta;

architecture ASM of Cinta is
    -- nombres de estado = nombres de los 4 bloques del diagrama ASM
    type mis_estados is (VACIO, UNA, DOS, LLENO);
    signal estado : mis_estados;

    -- sincronizador de 2 FF para S (entrada asíncrona) + retardo extra:
    -- el frente de subida es s2=1 con s3=0; el nivel dura N ciclos indeterminados
    signal s1, s2, s3 : std_logic;
begin
    ------- PROCESO 1: sincronizador antirrebote de S (Tema 3, págs. 30-32) -------
    -- bloque aparte, con su propio reset asíncrono
    process (clk, rst)
    begin
        if rst = '1' then
            s1 <= '0';  s2 <= '0';  s3 <= '0';   -- reset asíncrono: actúa sin flanco
        elsif rising_edge(clk) then
            s1 <= S;  s2 <= s1;  s3 <= s2;
        end if;
    end process;

    ------- PROCESO 2: estado (4 bloques de la ASM) + salida Moore Y -------
    process (clk, rst)
    begin
        if rst = '1' then
            estado <= VACIO;
            Y <= '0';                         -- con reset activo la cinta está parada
        elsif rising_edge(clk) then
            case estado is                    -- lee s2/s3 tal como quedaron en el flanco anterior
                when VACIO =>                          -- bote nuevo en su sitio, 0 pelotas
                    Y <= '0';
                    if s2 = '1' and s3 = '0' then estado <= UNA;  -- frente de S
                    end if;
                when UNA =>                            -- 1 pelota en el bote
                    Y <= '0';
                    if s2 = '1' and s3 = '0' then estado <= DOS;  -- frente de S
                    end if;
                when DOS =>                            -- 2 pelotas en el bote
                    Y <= '0';
                    if s2 = '1' and s3 = '0' then estado <= LLENO;  -- 3ª pelota: lleno
                    end if;
                when LLENO =>                          -- Y=1: la cinta avanza hasta traer el bote
                    Y <= '1';
                    if B = '1' then estado <= VACIO;   -- B es NIVEL: esperar
                    end if;
                when others =>
                    estado <= VACIO;  Y <= '0';
            end case;
        end if;
    end process;
end architecture ASM;

Notas para el examen: el rst es asíncrono (va en la lista de sensibilidad de los dos procesos, process (clk, rst), con la rama if rst = '1' delante de elsif rising_edge(clk)): mientras vale 1 la cinta está parada (Y=0) y el estado es VACIO, y actúa sin esperar a ningún flanco de reloj — así lo pide el Tema 3 (págs. 30–32, la tarjeta con reloj y reset). Los nombres de los estados VHDL son exactamente los cuatro rótulos de la ASM, y el P2 de este examen cuenta con ellos. La condición de frente se escribe tal cual (s2 = '1' and s3 = '0'): s1/s2 son el sincronizador antirrebote y s3 es el retardo con el que se compara; no es un tercer estado. El sincronizador va en su propio proceso (un bloque por pieza, igual que un contador iría aparte de la ASM): el case del proceso de estado lee s2/s3 tal como quedaron en el flanco anterior, lo que hace determinista el disparo. No hay contadores aquí: el contaje vive en los cuatro estados.

Errores típicos — P1

Esquema-resumen de la metodología

  1. Seca el enunciado en dos columnas — lo que fija (3 pelotas, Y mientras dura la orden, B nivel, pulsos S sin solapar y de duración indeterminada) frente a lo que NO fija (nada de tiempos: prohíbe inventar frecuencias; y documenta supuestos como el de la pelota que cae con la cinta en marcha).
  2. Clasifica cada entrada por su naturaleza de temporización — B es nivel mantenido, S es un PULSO de duración indeterminada → la unidad de información es su frente, no su nivel. Aquí se juega el ejercicio: detecta el frente y la ASM deja de contar de más.
  3. Convierte el contaje en estados — con solo 4 valores posibles, un estado por contenido (VACIO/UNA/DOS/LLENO) y la tabla de transiciones del Tema 3; el contador separado solo compensa si hay que visualizar o el contaje es grande.
  4. Dibuja la ASM con las salidas dentro de la caja de estado — Y en LLENO (Moore) porque «avanza mientras recibe un 1»; transiciones etiquetadas por frente; decisión B como nivel.
  5. Traduce a VHDL con la estructura de clase — dos procesos con reset asíncrono (process (clk, rst) + if rst = '1' + elsif rising_edge(clk)): el de la ASM (estado y salidas, con reset a VACIO/reposo) y el del sincronizador/filtro de frente en bloque aparte; salida Y escrita en todas las ramas y when others; nombres de estado = rótulos de la ASM.
  6. Compruébalo con pulsos asimétricos — testbench con duraciones distintas (1, 2, 7, 9 ciclos), niveles mantenidos (B) y un espejo con las reglas literales: el bug de contar niveles solo se ve si los pulsos tienen anchos variados y se coteja flanco a flanco.

Idea transversal: cuando el enunciado dice «el pulso puede durar un número indeterminado de ciclos», no está decorando — está diciendo que tu ASM debe mirar FRENTES y no NIVELES. Es la misma doctrina del antirrebote del Tema 3 y del sondeo por frentes del P2 picoBlaze de este examen: cambia la tecnología (ASM/VHDL vs. microcontrolador), el frente manda.


Problema 2 — Cinta de botes de pelotas con microcontrolador picoBlaze (3,5 puntos)

Figura del enunciado (imagen nativa del PDF): la cinta con botes de pelotas de tenis y los sensores S y B que hay que gobernar con el picoBlaze.
Figura del enunciado (imagen nativa del PDF): la cinta con botes de pelotas de tenis y los sensores S y B que hay que gobernar con el picoBlaze.

Planteamiento. El enunciado retoma el sistema del Problema 1 (pelotas que caen por un tolva a un bote sobre una cinta; la cinta avanza mientras recibe un 1 por Y al llenarse el bote con 3 pelotas, y el sensor B indica con nivel alto que el bote nuevo quedó en su sitio) y pide gobernarlo con un microcontrolador PicoBlaze en vez de una ASM/VHDL, añadiendo un visualizador de 7 segmentos que muestre el número de pelotas del bote (0, 1, 2 o 3). El examen imprime el bloque «PicoBlaze Microcontroller» y la tabla de instrucciones, que es la única ISA válida aquí. El programa es la traducción del control a secuencia recta: sondeo del sensor S contando frentes de subida (los pulsos duran un número indeterminado de ciclos), escritura enmascarada de las salidas por latch y decisión de bote lleno con contador de 3 valores.

Datos que fija el enunciado y decisiones de diseño

Fija el enunciado: el proceso del Problema 1 (sensor fotoeléctrico S activo a nivel alto cuando cae una pelota, pulsos sin solaparse y con duración indeterminada; sensor B nivel alto = bote nuevo colocado; la cinta avanza mientras recibe un 1 por Y; bote lleno = 3 pelotas); el visualizador de 7 segmentos con el número de pelotas (0, 1, 2 o 3); el bloque impreso en la hoja «PicoBlaze Microcontroller», con solo los pines IN_PORT[7:0], INTERRUPT, RESET, CLK por la izquierda y OUT_PORT[7:0], PORT_ID[7:0], READ_STROBE, WRITE_STROBE, INTERRUPT_ACK por la derecha; y la tabla de instrucciones impresa (transcrita y verificada en la auditoría: ADD/ADDC/SUB/SUBC en formas sX,sY y sX,kk; desplazamientos SL0/SL1/SLX/SLA y SR0/SR1/SRX/SRA; RL/RR; AND/OR/XOR; COMP/TEST; LOAD sX,sY y LOAD sX,kk; IN/OUT en formas sX,(sY) y sX,kk; FETCH/STORE; saltos JUMP/CALL en formas libres y con condiciones (N)Z y (N)C únicamente; RET; EINT, DINT y RETI. La tabla no imprime CONSTANT ni RETURN). Baremo: a) 1 p + b) 2,5 p = 3,5 p.

No lo fija el enunciado (supuestos de la guía, documentados):

  1. Memoria de programa. El bloque impreso en la hoja no saca pines ADDRESS/INSTRUCTION: en el modelo del tema el firmcore consta de dos módulos, el núcleo KCPSM3 y un bloque RAM que aloja el programa (1K×18 con WE a 0). Declaro la memoria de programa como ROM externa 1024 × 18 — lo máximo direccionable del KCPSM3 (1024 posiciones, vector de interrupción en 3FFH).
  2. Puertos y mapa de bits. Puerto de lectura H"00" (bit0 = S, bit1 = B, bits 2–7 libres) y puertos de escritura H"00" (bit0 = Y, bits 1–7 libres) y H"01" (el patrón del visualizador). Lectura y escritura pueden compartir número de puerto: lo distingue la strobe del ciclo (READ_STROBE en IN, WRITE_STROBE en OUT).
  3. Codificación del visualizador. El examen no da la codificación. Declaro ánodo común (segmento encendido = 0) y patrón {dp,g,f,e,d,c,b,a} — la misma del ejemplo del tema: '0' = H"C0", '1' = H"F9", '2' = H"24", '3' = H"B0" (despiece abajo). Con otra codificación el programa no cambia: solo cambian los cuatro valores.
  4. Conteo por frentes, no por niveles. Como el pulso de S puede durar muchos ciclos, tras detectar S a 1 el programa espera el flanco bajo (JUMP NZ en bucle) antes de contar la pelota siguiente; y lo mismo tras colocar el bote nuevo (el pulso que llenó el bote anterior puede solapar con la colocación). Sin esa espera, la misma pelota se contaría varias veces.
  5. Ninguna pelota cae mientras la cinta está en marcha (el enunciado da espacio temporal entre pelotas, y el avance es corto). Si cayera, el programa no la contaría durante el tramo AVANZA (queda documentado como límite del diseño).
  6. Sondeo, no interrupción. Los sensores se consultan por lectura (IN + TEST + JUMP Z), sin INTERRUPT/INTERRUPT_ACK ni vector 3FFH: el baremo no pide interrupciones y el sondeo es el camino corto. La tabla imprime EINT/DINT/RETI, pero este diseño no los usa.

Cálculos previos: los cuatro dígitos en hexadecimal

Patrón de 8 bits {dp,g,f,e,d,c,b,a}, ánodo común (0 = segmento encendido), calculado a mano y declarado en el recuadro (decisión 3):

La comprobación: el ejemplo del tema con la scratchpad como tabla de patrones usa exactamente esta codificación (LED_0 EQU 0xC0, LED_1 EQU 0xF9, patrón {dp,g,f,e,d,c,b,a}), así que los H"C0" y H"F9" de la guía coinciden con los de sus apuntes. El visualizador es el mismo hardware del proceso (el micro solo escribe su patrón; no hace falta decodificador en la FPGA).

a) Diagrama hardware y memoria de programa (1 punto)

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

El diagrama se apoya en el bloque impreso en el examen (firmcore PicoBlaze con sus 9 pines) y añade lo que el enunciado exige: conexiones, E/S y memoria de programa. Lo que se dibuja, paso a paso:

  1. Núcleo KCPSM3 embebido en la FPGA, fiel al bloque impreso: IN_PORT[7:0], INTERRUPT, RESET, CLK por la izquierda; OUT_PORT[7:0], PORT_ID[7:0], READ_STROBE, WRITE_STROBE, INTERRUPT_ACK por la derecha. INTERRUPT e INTERRUPT_ACK quedan sin conectar (sondeo por lectura, decisión 6 del recuadro; el vector 3FFH de la ROM queda libre). El CLK va al núcleo y el RESET sincronizado inicializa el firmcore con el programa arrancando en bote vacío y cinta parada.
  2. Memoria de programa: ROM 1024 × 18. El bloque impreso no saca ADDRESS[9:0]/INSTRUCTION[17:0], pero en el modelo del tema el firmcore necesita su bloque de programa: ADDRESS[9:0] sale a la ROM (block RAM de la FPGA con WE a 0 para que parezca ROM) e INSTRUCTION[17:0] vuelve de ella. El programa del apartado b) ocupa 35 posiciones de las 1024: sobra con holgura.
  3. Entradas con lectura aislada por strobe. Los dos sensores entran al bus IN_PORT[7:0] a través de lógica tri-state habilitada al comparar PORT_ID = H"00" con READ_STROBE (en el dibujo se agrupan en un mux 2:1 con dos comparadores: funcionalmente es equivalente).
  4. Salidas con latch por WRITE_STROBE. Dos latches: el del puerto H"00" (bit0 = Y — el latch mantiene Y=1 mientras el micro espera el sensor B, y por eso la cinta no se para sola—) y el del puerto H"01" (el patrón del visualizador, que también queda fijado). Cada OUT escribe la máscara completa del latch: ningún bit queda ambiguo.
  5. La máquina del enunciado cuelga del micro. La cinta recibe Y del latch H"00"; los sensores S y B realimentan al bus IN_PORT; el visualizador recibe el patrón del latch H"01".

Diagrama hardware del control de la cinta de botes: PicoBlaze KCPSM3 clk (reloj de la FPGA) reset (sincronizado) KCPSM3 (firmcore 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 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-3FFH: 1024 instr. de 18 bits ADDRESS[9:0] = 2^10 = 1024 el programa ensamblado usa 35 posiciones: sobra con holgura vector 3FFH: sin usar 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 selecciona comparando PORT_ID con la strobe del ciclo sensor S (bit0) sensor B (bit1) = H"00" = H"00" MUX 2:1 IN_PORT[7:0] READ_STROBE + PORT_ID PORT_ID WRITE_STROBE = H"00" (port_id) AND + WRITE latch salida puerto H"00": bit0=Y = H"01" (port_id) AND + WRITE latch salida puerto H"01": 7 seg visualizador 7 segmentos (an. comun) OUT, H"01" proceso: cinta + botes pelotas, sensores S y B de la figura del enunciado Y (cinta) sensores y pelotas realimentan el puerto H"00" el micro sondea los sensores: lee el puerto H"00" con IN y prueba un bit con TEST + JUMP Z las salidas se escriben con la mascara completa del latch (H"00" la Y de la cinta, H"01" el digito) INTERRUPT, INTERRUPT_ACK y el vector 3FFH quedan sin usar: sondeo por lectura

📚 Teoría: Tema 4, pág. 11–12 del PDF «Tema 4 SD-II_20220512.pdf» — PicoBlaze: microcontrolador de 8 bits embebido en FPGA, 1024 instrucciones, 16 registros y diagrama de bloques. 📚 Teoría: Tema 4, pág. 31 y 33 del PDF «Tema 4 SD-II_20220512.pdf» — puertos de E/S: PORT_ID, strobes de lectura/escritura y conexión de múltiples fuentes a IN_PORT[7:0]. 📚 Teoría: Tema 4, pág. 34 del PDF «Tema 4 SD-II_20220512.pdf» — conexión de salidas del micro a la lógica de la FPGA. 📚 Teoría: Tema 4, pág. 45 del PDF «Tema 4 SD-II_20220512.pdf» — el firmcore son dos módulos (KCPSM3 + bloque RAM 1K×18 con WE a 0 como ROM de programa).

b) Programa en ensamblador comentado (2,5 puntos)

Tabla de instrucciones impresa en el examen: la única ISA válida del problema (auditoría visual en varias pasadas por bandas: RET, sin RETURN ni CONSTANT; IN/OUT en formas sX,(sY) y sX,kk; JUMP (N)Z y (N)C; EINT/DINT/RETI presentes).
Tabla de instrucciones impresa en el examen: la única ISA válida del problema (auditoría visual en varias pasadas por bandas: RET, sin RETURN ni CONSTANT; IN/OUT en formas sX,(sY) y sX,kk; JUMP (N)Z y (N)C; EINT/DINT/RETI presentes).

Convenciones de la tabla impresa en este examen (las únicas que se usan):

El programa (35 posiciones de la ROM; verificado con un mini-emulador KCPSM3 del subconjunto de la tabla impresa, con el proceso físico modelado de forma independiente del programa — autoauditoría en guias/NOTAS-elaboracion-junio-2023.md):

;=====================================================================
; Control de la cinta de botes de pelotas de tenis (Junio-2023) con PicoBlaze
; Unicos mnemonicos validos: los de la tabla impresa en el examen.
; Aqui se usan LOAD, ADD, COMP, IN, OUT, TEST y JUMP (etiq, Z y NZ).
;
; Puerto de lectura  H"00": bit0=S (fotoelectrico: cae una pelota)
;                        bit1=B (nuevo bote colocado en su sitio)
; Puerto de salida   H"00": bit0=Y (avance de la cinta)
; Puerto de salida   H"01": patron 7 segmentos {dp,g,f,e,d,c,b,a}, anodo comun
;                        '0'=H"C0"  '1'=H"F9"  '2'=H"24"  '3'=H"B0"
;=====================================================================
P_ENT  EQU H"00"           ; puerto de lectura de sensores (decision propia)
P_Y    EQU H"00"           ; puerto de la senal Y de la cinta (mismo numero,
                           ;  distinto ciclo: la strobe del IN/OUT lo decide)
P_SEG  EQU H"01"           ; puerto del visualizador de 7 segmentos

        ORG H"000"
; ---------------------------------------------------------------------
; Arranque: bote vacio (contador 0, pantalla '0') y cinta parada (Y=0).
; ---------------------------------------------------------------------
INICIO: LOAD s0, H"00"     ; s0 = pelotas en el bote actual (0..3)
        LOAD s3, H"C0"     ; patron del digito '0'
        LOAD s2, H"00"     ; mascara Y=0: cinta parada
        OUT s2, P_Y        ; aseguramos la cinta parada al arrancar
; ---------------------------------------------------------------------
; Cuerpo del ciclo: mostrar el numero, sondear el sensor S y contar el
; frente de subida. El digito se escribe con el OUT de la cabecera del
; bucle, que el latch mantiene mientras el micro sigue sondeando.
; ---------------------------------------------------------------------
BUCLE:  OUT s3, P_SEG      ; pantalla con el numero actual (0..3)
        IN  s1, P_ENT      ; leo los sensores (S en bit0, B en bit1)
        TEST s1, H"01"     ; pruebo S: Z=1 mientras S este a 0
        JUMP Z, BUCLE      ; no hay pelota: sigo sondeando
        ADD  s0, H"01"     ; una pelota mas: s0 = s0 + 1
        COMP s0, H"03"     ; ?es la tercera pelota?
        JUMP Z, LLENO      ; si: hay que cambiar el bote
        COMP s0, H"01"
        JUMP Z, UNO        ; primera pelota: pantalla '1'
        COMP s0, H"02"
        JUMP Z, DOS        ; segunda pelota: pantalla '2'
UNO:    LOAD s3, H"F9"     ; patron del digito '1'
        JUMP SUELTA
DOS:    LOAD s3, H"24"     ; patron del digito '2'
; ---------------------------------------------------------------------
; Espera de suelta: el pulso de S puede durar muchos ciclos; sin esperar
; el flanco bajo, la misma pelota se contaria varias veces (los pulsos de
; las pelotas no se solapan, asi que el flanco bajo marca el fin).
; ---------------------------------------------------------------------
SUELTA: IN  s1, P_ENT      ; espero el fin del pulso de S
        TEST s1, H"01"     ; Z=0 mientras S se mantenga a 1
        JUMP NZ, SUELTA    ; al bajar S, la pelota ya esta contada
        JUMP BUCLE         ; y el bucle saca la pantalla '1' o '2'
; ---------------------------------------------------------------------
; Bote lleno (3 pelotas): pantalla '3', Y=1 (avanza la cinta) y esperar
; el sensor B del bote nuevo. Y=1 queda en el latch durante el trayecto.
; ---------------------------------------------------------------------
LLENO:  LOAD s3, H"B0"     ; patron del digito '3'
        OUT s3, P_SEG      ; el bote lleno se ve en la pantalla
        LOAD s2, H"01"     ; Y=1: cinta en marcha
        OUT s2, P_Y
AVANZA: IN  s1, P_ENT      ; espero el sensor B (bit1)
        TEST s1, H"02"     ; Z=1 mientras el bote nuevo no este colocado
        JUMP Z, AVANZA     ; la cinta sigue avanzando (Y=1 en el latch)
; Bote nuevo en su sitio: parar la cinta y reiniciar el conteo.
        LOAD s2, H"00"     ; Y=0: paro la cinta
        OUT s2, P_Y
        LOAD s0, H"00"     ; el bote nuevo empieza con 0 pelotas
        LOAD s3, H"C0"     ; patron del digito '0'
        OUT s3, P_SEG      ; pantalla 0: el bote esta aun vacio
        JUMP SUELTA        ; no hay que contar la pelota mientras S siga
                           ;  alto (el pulso que lleno el bote anterior puede
                           ;  solapar con la colocacion del bote nuevo)

Justificaciones que el examinador pide explicar:

Trazada de verificación (mini-emulador de la ISA impresa + entorno con la máquina del enunciado modelada independientemente del programa: pulsos de S de duración variable —el tercero de un bote dura 40 ciclos y se solapa con el avance—, viaje de la cinta de 10 ciclos tras Y=1 y B mantenido 5 ciclos; el contador físico de pelotas se incrementa solo en el frente de subida de S):

Secuencia esperada por bote (3 botes, 9 pelotas):
  dígito: C0 '0' → F9 '1' → 24 '2' → B0 '3' → (Y=1, espera B) → C0 '0'...
  mascara Y: H"01" al llenarse → H"00" al llegar B  (tres veces)
Asserts: el digito visible debe coincidir con el contador FISICO del bote (o con
3 durante el avance); la cinta no puede estar en marcha con el bote mostrando
distinto de 3; ningun pulso se cuenta dos veces ni se duplica el solapado con el
avance; cota de pasos que descarta bucles infinitos. Un alijo de 7 errores
inyectados al ensamblador (bit probado inexistente, bit equivocado en B, quita de
la espera de suelta, avance tras 2 pelotas, Y que nunca se enciende, patron '1'
mal, suma de 2 en 2) hace saltar todos los asserts: el harness no es decorativo.
**TRAZADA OK.**

📚 Teoría: Tema 4, pág. 27 del PDF «Tema 4 SD-II_20220512.pdf» — TEST deja ZERO=1 si el AND da 0 (y C por paridad de sX). 📚 Teoría: Tema 4, pág. 28 del PDF «Tema 4 SD-II_20220512.pdf» — COMP resta y afecta solo a los flags ZERO/CARRY. 📚 Teoría: Tema 4, pág. 30 del PDF «Tema 4 SD-II_20220512.pdf» — control del flujo: JUMP/CALL condicionados a ZERO y CARRY. 📚 Teoría: Tema 4, pág. 41 del PDF «Tema 4 SD-II_20220512.pdf» — alternativa con la scratchpad RAM como tabla de patrones para el visualizador de 7 segmentos (y la codificación {dp,g,f,e,d,c,b,a} del ejemplo).

Errores típicos — P2

Baremo real del problema

a) Diagrama hardware de bloques (conexiones, E/S y memoria de programa) = 1 punto; b) programa en ensamblador que controle el sistema = 2,5 puntos. Suma 3,5 p y cuadra con el enunciado: sin erratas.

Esquema-resumen de la metodología

  1. Leer el bloque y la tabla impresos — el examen da el firmcore con sus pines y su tabla de instrucciones (exclusiva del examen: retranscribirla siempre; el conjunto de mnemónicos cambia entre exámenes). El diagrama se dibuja alrededor de esos pines y el ensamblador solo puede usar mnemónicos de la tabla.
  2. Fijar el mapa de E/S antes de programar — EQU de puertos y mapa de bits comentado: sensores por un puerto de lectura, la Y de la cinta por el puerto de escritura H"00" y el visualizador por el H"01".
  3. Traducir el control a secuencia recta — sondeo IN + TEST + JUMP Z; cada decisión del grafo (1, 2, 3 pelotas) es un COMP + JUMP Z sobre el contador; cada salida larga (la cinta en marcha) es un latch que se escribe una vez y se apaga al llegar el sensor final.
  4. Cerrar cada lectura de sensor con su flanco de vuelta — un pulso de duración indeterminada exige esperar el nivel bajo (JUMP NZ en bucle) antes de volver a sondear; lo mismo al cambiar de bote.
  5. Salidas que no se auto-explican: declararlas — los cuatro dígitos del visualizador se calculan a mano contra la codificación declarada (y cuadran con el ejemplo de los apuntes) y viajan en un registro para escribirlos por OUT.
  6. Verificar con emulador — el mini-emulador de la ISA impresa compara el programa con la máquina física (contador de pelotas independiente, pulsos de duración variable, viaje de la cinta con B temporizado): el programa puede estar bien de lógica y fallar justo en el solape de pulsos.

Idea transversal: la ASM del Problema 1 no desaparece, se traduce: cada caja del grafo es un bloque recto OUT (máscara completa) + sondeo con espera de flanco. El trabajo duro del ejercicio está en el conteo por frentes (pulsos de duración indeterminada) y en respetar la tabla impresa, no en la aritmética: un contador de 0 a 3 con ADD/COMP cabe en cinco líneas.


Problema 3 — Unidad de procesado von Neumann: microoperaciones y UC (3,5 puntos)

Figura del enunciado (imagen nativa del PDF): la Unidad de Procesado de Datos von Neumann con los registros PC, AC, MAR, IR, Buffer, SAR, la ALU y las señales de control C0–C18.
Figura del enunciado (imagen nativa del PDF): la Unidad de Procesado de Datos von Neumann con los registros PC, AC, MAR, IR, Buffer, SAR, la ALU y las señales de control C0–C18.

Planteamiento. La figura del examen (recorte nativo figuras/jun23/recortes/datapath-p3-nativa.jpg) dibuja la Unidad de Procesado de Datos de un microprocesador von Neumann: bus de datos de 8 bits compartido y bus de direcciones de 16 bits, con registros PC (PCH+PCL), AC (la caja «A» con salida con OE), MAR (MARH+MARL), IR, Buffer (registro temporal) y SAR (SRARH+SRARL), una ALU con la tabla de funciones impresa y flags C/Z. El apartado a) pide la secuencia de microoperaciones de las 7 instrucciones de la tabla impresa (LDAC/CMAC/ADD/STAC/SUBR/RTN/STOP) usando las señales de control C0–C18 que rotula la figura. El apartado b) pide diseñar la unidad de control con la estructura Multiplexor–Contador–Memoria (el modelo del Tema 5).

Datos que fija el enunciado y decisiones de diseño

Fija el enunciado: el bus de datos de 8 bits y el de direcciones de 16; PC de 16 formado por PCH y PCL; AC de 8; MAR de 16 formado por MARH y MARL; IR de 8; Buffer de 8 «utilizado para el cálculo de operaciones intermedias»; SAR de 16 «para guardar direcciones en las llamadas a subrutinas». La ISA impresa con código y longitud: LDAC <dir> = 00000010 (3 bytes), CMAC = 00000011 (1), ADD <dir1> <dir2> = 00000100 (5), STAC <dir> = 00000101 (3), SUBR <dir> = 00000110 (3), RTN = 00000111 (1), STOP = 00000001 (1). La tabla del PC impresa (C2 C1 C0): 000 = RESET, 001 = CUENTA, 100 = carga paralela PCH, 101 = carga paralela PCL. La tabla de la ALU impresa (C12 C11 C10 → F): 000 = 0, 001 = L+R, 010 = L+1, 011 = L AND R, 100 = NOT L. Baremo: a) microoperaciones 2,5 p + b) UC 1 p = 3,5 p.

No lo fijan el papel/figura (supuestos de la guía, decláralos en el examen):

  1. Errata en la descripción del ADD. La tabla imprime «Resta AC – dato – M» bajo un nemónico ADD, y la propia tabla ALU del examen no tiene resta (sus funciones son 0, L+R, L+1, AND, NOT). Se resuelve como suma encadenada AC + M(dir1) + M(dir2) con el Buffer de puente entre lectura y ALU, y se documenta la errata sin cambiar el literal.
  2. Orden de los bytes de <dir>. El enunciado no lo dice (junio-2024 sí especifica «primero la parte alta»). Supuesto declarado: primero la parte ALTA, después la BAJA, igual que el orden PCH–PCL del PC.
  3. Trazado de los dos MUX de 4 entradas. La jpeg de la figura es ambigua en los cruces; el trazado supuesto (simétrico): MUX hacia PC (selectores C4 C3): 00=bus de datos, 01=SAR, 10=PC (realimentación), 11=salida F de la ALU; MUX hacia MAR (selectores C6 C5): 00=SAR, 01=PC, 10=bus de datos, 11=F. Las salidas de 8 se bifurcan a las dos mitades (punto en el dibujo): con C8 activa carga la alta y con C7 la baja.
  4. Señales de memoria. La figura no dibuja R/W en el «ESPACIO DIRECCIONABLE»: se declaran RD (habilitación de lectura) y pulso WE̅ (escritura); el dato leído sale al bus de datos y el escrito entra por el bus.
  5. Mantenimiento del PC. La tabla impresa del PC no trae fila de «mantener» (000 es RESET): la parada de STOP no se hace con el PC sino deteniendo el contador de la UC (apartado b), y durante todo lo demás el PC solo cuenta o carga lo que pide el programa.
  6. SAR ← PC directo (camino dedicado). SUBR necesita guardar la dirección de retorno mientras el bus está ocupado por el operando; se usa un camino directo PC→SAR que captura en el flanco sin tocar el bus de datos (alternativa: hacer SAR ← PC en dos ciclos vía bus — encarece la secuencia, el camino dedicado es la opción corta y queda declarada).

a) Secuencia de microoperaciones del juego de instrucciones (2,5 puntos)

Convenciones de lectura. El bus de datos admite un solo emisor por ciclo. Cada transferencia por el bus se hace en dos tiempos: en el primer ciclo el emisor pone el dato en el bus y, en el flanco, el registro al que se le ha activado su carga lo captura; si el destino es un registro de 16, cada mitad exige su propio ciclo (de ahí que MAR ← dirección requiera un ciclo para la alta con C8 y otro para la baja con C7). La lectura de memoria exige MAR completo antes de activar RD. Las señales que se nombran son las de la figura: C2C1C0 tabla del PC, C4C3 selector MUX→PC, C6C5 selector MUX→MAR, C7 carga MARL, C8 carga MARH, C9 carga IR, C10C11C12 función ALU, C13 carga Buffer, C14 carga A (AC), C15 OE de A (su salida es la entrada L de la ALU; la entrada R sale fija del Buffer), C16 captura flags C/Z, C17 carga SRARL, C18 carga SRARH, más RD/WR declaradas.

Datapath del P3 junio-23: bus de datos 8 compartido, direcciones 16 redibujado fiel a la figura del examen; senales C0-C18 segun la auditoria visual (notas en figuras/jun23) C2C1C0 (tabla PC): 000 RESET · 001 CUENTA · 100/101 PCH/PCL PCH PCL PC de 16, mitades de 8 MUX S=C4C3 MUX S=C6C5 MARH MARL C8 MARH · C7 MARL IR (8) carga C9 ESPACIO DIRECCIONABLE direcciones 16 · datos 8 RD y pulso WE (declaradas) BUS DIRECCIONES (16) datos 8 IR: C9 SRARH SRARL C18 SRARH · C17 SRARL PC a SAR (SUBR) SAR (01) SAR (00) bus (00) bus (10) A (AC, 8) C14 · OE: C15 BUFFER (8) C13 · a bus ALU (8) funcion: C10C11C12 L (via OE C15) R ← BUF F al bus flags C / Z captura C16 BUS DE DATOS (8) - un solo emisor por ciclo; cada carga captura en el flanco MUX PC (C4C3): 00=bus datos, 01=SAR, 10=PC realimentado (no dibujado), 11=F. MUX MAR (C6C5): 00=SAR, 01=PC, 10=bus datos, 11=F. La salida de 8 de cada MUX se bifurca a mitad alta (C8 con C2C1C0=100) y a mitad baja (C7/101). ALU (C12C11C10) segun la tabla impresa: 000 salida 0, 001 L+R, 010 L+1, 011 L AND R, 100 NOT L. Flags C y Z con C16. El punteado morado PC-SAR es el camino dedicado de SUBR; demas senales C0-C18 como en la figura del examen.

Fetch común (3 ciclos, T0–T2). Vale para las 7 instrucciones; el opcode queda en IR y el PC queda apuntando al primer operando:

T0: MARH ← PCH   (MUX→MAR = PC: C6C5=01; C8; el bus queda libre)
T1: MARL ← PCL   (C7) ; PC cuenta (C2C1C0=001)
T2: bus ← M[MAR] (RD) ; IR ← bus (C9)          ← tras este ciclo despacha la UC

LDAC <dir> — «Carga en AC el dato situado en la dirección <dir>» (9 ciclos). <dir> está en memoria (2 bytes), así que la dirección viaja por el bus y hace de puente el SAR (la figura lo saca por el MUX hacia MAR):

E1: MARH ← PCH            (MUX→MAR=PC, C8)
E2: MARL ← PCL            (C7)
E3: bus ← M[MAR] (=dir alta) ; SRARH ← bus (C18) ; PC cuenta (001)
E4: MARH ← PCH            (C8) ;  E5: MARL ← PCL (C7)
E6: bus ← M[MAR] (=dir baja) ; SRARL ← bus (C17) ; PC cuenta (001)
E7: MARH ← SRARH          (MUX→MAR=SAR: C6C5=00; C8)
E8: MARL ← SRARL          (C7)
E9: bus ← M[MAR] (=dato) ; AC ← bus (C14)

STAC <dir> — «Guardar AC en M» (9 ciclos): E1–E8 idénticos a LDAC (la dirección también viaja por SAR); E9 cambia el sentido del bus:

E9: bus ← AC (OE C15) ; M[MAR] ← bus (pulso WE̅)

CMAC — «Complemento a 2 del AC» (2 ciclos). Sin restar hardware: NOT y luego +1, que son dos de las funciones impresas de la ALU (100 y 010), con AC haciendo de L a través de su OE:

E1: L=AC (C15) ; F=NOT L (C12C11C10=100) ; bus ← F ; AC ← bus (C14) ; C16
E2: L=AC (C15) ; F=L+1 (010) ; bus ← F ; AC ← bus (C14) ; C16

ADD <dir1> <dir2> — con la errata documentada: suma encadenada (20 ciclos). El nemónico es ADD; se suma AC+M(dir1) y después el resultado+M(dir2). El Buffer hace de puente entre cada lectura de memoria y la entrada R de la ALU (que está fija en el Buffer):

E1-E9:   igual que LDAC, pero E9: bus ← M[MAR] (=M[dir1]) ; Buffer ← bus (C13)
E10: L=AC (C15) ; R=Buffer ; F=L+R (001) ; bus ← F ; AC ← bus (C14) ; C16
E11-E19: igual que E1-E9 con la segunda dirección: E19: bus ← M[MAR] (=M[dir2]) ; Buffer ← bus
E20: L=AC (C15) ; R=Buffer ; F=L+R (001) ; bus ← F ; AC ← bus (C14) ; C16

SUBR <dir> — «Saltar a la subrutina en <dir>» (8 ciclos). Doble trabajo: el PC debe quedarse con <dir> y el SAR con la dirección de retorno (el PC tras consumir el operando). El byte bajo del operando se guarda en el Buffer (el SAR acaba de usarse para la alta), y el retorno entra en SAR por el camino dedicado PC→SAR (decisión 6 del recuadro):

E1: MARH ← PCH (C8) ; E2: MARL ← PCL (C7)
E3: bus ← M[MAR] (=dir alta) ; SRARH ← bus (C18) ; PC cuenta (001)
E4: MARH ← PCH (C8) ; E5: MARL ← PCL (C7)
E6: bus ← M[MAR] (=dir baja) ; Buffer ← bus (C13) ; PC cuenta (001) → PC = dirección de retorno
E7: bus ← SRARH (=dir alta, con MUX→PC=SAR: C4C3=01) ; PCH ← bus (100) ;
    SAR ← PC en el mismo flanco (camino dedicado, no usa el bus) → SAR = retorno
E8: bus ← Buffer (=dir baja, MUX→PC=bus: C4C3=00) ; PCL ← bus (101) ; PC = <dir>

RTN — «Volver desde subrutina» (2 ciclos): el SAR (que guarda la dirección de retorno) entra al PC por el MUX dedicado:

E1: PCH ← SRARH (MUX→PC=SAR: C4C3=01; C2C1C0=100)
E2: PCL ← SRARL (C2C1C0=101)

STOP — «Detener CPU» (1 ciclo):

E0: la UC se para (el contador de microprograma deja de contar; bus libre, sin lecturas)

Con el PC no hace falta tocarlo: la tabla impresa no tiene «mantener» y el microprograma simplemente deja de avanzar (decisión 5 del recuadro).

Recuento de ciclos (fetch + ejecución; cuadra con el verificador del datapath):

Instrucción Cod. Bytes Fetch+Ejec. Ciclos de ejecución
LDAC <dir> 00000010 3 3 + 9 = 12 9
CMAC 00000011 1 3 + 2 = 5 2
ADD <dir1> <dir2> 00000100 5 3 + 20 = 23 20
STAC <dir> 00000101 3 3 + 9 = 12 9
SUBR <dir> 00000110 3 3 + 8 = 11 8
RTN 00000111 1 3 + 2 = 5 2
STOP 00000001 1 3 + 1 = 4 1

📚 Teoría: Tema 5, pág. 17–18 del PDF «Tema 5 SD-II_20230215.pdf» — microprograma simbólico de referencia: fetch común (MAR ← PC, lectura M(MAR)→IR y PC ← PC+1) y salto de despacho al entrar el opcode en IR.

Verificación (modelo Python del datapath REAL de la figura, ejecutado): el programa test LDAC $0100 · CMAC · STAC $0200 · ADD $0100 $0101 · SUBR $4000 · STOP@$000F (con M[$0100]=07, M[$0101]=05 y RTN en $4000) recorre el ciclo exacto de las tablas de arriba: 7 fetch (21) + 9+2+9+20+8+2 de ejecución = 71 ciclos (el verificador no suma el ciclo de parada de STOP), con las reglas de disciplina de bus (un solo emisor por ciclo, MAR completo antes de cada acceso, IR solo tras lectura de memoria). Resultados observados: AC: 07 → CMAC → F9 → STAC deja M[$0200]=F9 → ADD: F9+07 = 100H→00 con C=1, +05 = AC=05; SUBR deja SAR=$000F (retorno) y PC=$4000; RTN: PC=$000F (STOP); SAR final=$000F, PC=$0010 (el fetch de STOP ya contó, la UC detiene el contador). Alijo negativo 3/3: dos emisores en el mismo ciclo → colisión detectada; acceso con MARL sin cargar → MAR incompleto detectado; IR cargado de un registro (sin lectura de memoria) → IR sin MEM detectado. TRAZADA OK.

b) Unidad de control con la estructura Multiplexor–Contador–Memoria (1 punto)

El microprograma simbólico usa las posiciones que marca la figura: el fetch ocupa 00H–02H y tras T2 el despacho por el opcode cuelga el contador a la base de cada instrucción (direcciones dadas por un pequeño decodificador de I2·I1·I0 — los códigos de la tabla impresa son únicos en esos 3 bits; el 000 no lo usa ninguna instrucción):

00H-02H  FETCH (T0, T1, T2; en 02H el multiplexor carga la base por IR)
03H-0BH  LDAC      0CH-0DH  CMAC      0EH-16H  STAC     17H-2AH  ADD
2BH-32H  SUBR      33H-34H  RTN       35H      STOP (contador parado)

Cada última microorden de instrucción lleva el campo de salto J = 00H (salto incondicional de vuelta al fetch), codificado como una entrada fija del multiplexor; la microorden 35H de STOP activa la parada del contador. Microprograma: 3+9+2+20+9+8+2+1 = 54 microórdenes (00H–35H) → contador MPC de 6 bits (64 ≥ 54) y memoria de control ROM de 64 × ~34 bits. Palabra de microorden (campos de la figura + salto):

Campo Bits Contenido
Selección de próximo MPC 2 00=contador+1 (CUENTA) · 01=carga J de la microorden · 10=base por IR (despacho) · 11=parada (STOP)
C2C1C0 3 tabla del PC (000 RESET, 001 CUENTA, 100 PCH, 101 PCL)
C4C3 y C6C5 2+2 selectores de los MUX hacia PC y hacia MAR
C7, C8, C9 3 carga MARL, MARH, IR
C10C11C12 3 función ALU
C13, C14, C15 3 carga Buffer, carga A, OE de A
C16 1 captura flags C/Z
C17, C18 2 carga SRARL, SRARH
RD, WR 2 lectura/escritura de memoria (declaradas)
SAR←PC 1 camino dedicado de SUBR
J (dirección de salto) 6 destino al hacer el salto incondicional

Total ≈ 34 bits → ROM 64×34. El CMBR (registro buffer de la memoria de control) es opcional según el tema. La estructura pedida es la clásica: el multiplexor eligiendo el próximo valor del contador MPC, cuyo contenido direcciona la memoria de control (ROM):

UC del P3 junio-23: estructura Multiplexor - Contador - Memoria 00=contador+1 (CUENTA), 01=J de la microorden, 10=base por IR (despacho tras el fetch), 11=parada STOP MULTIPLEXOR 00 01 10 CONTADOR MPC (6) carga por MUX (LOAD) CUENTA y RESET dir 6 MEMORIA DE CONTROL ROM 64 x ~34 bits microprograma: 54 microordenes posiciones 00H a 35H del mapa salida: campos de control C2C1C0, C4C3, C6C5, C7, C8, C9, C10C11C12, C13 a C18, RD/WR, camino SAR desde PC a la UO (datapath) contador + 1 (CUENTA) J (6 bits) IR (8) opcode tras C9 DEC: I2I1I0 a base 7 entradas, 6 bits base por IR llega del datapath (C9) condicion STOP (35H) bloquea CUENTA y LOAD descodifica 35H RESET en arranque y parada El microprograma en la ROM (posiciones en hex): 00H-02H fetch comun, 03H-0BH LDAC, 0CH-0DH CMAC, 0EH-16H STAC, 17H-2AH ADD, 2BH-32H SUBR, 33H-34H RTN, 35H STOP. Al final de cada instruccion el campo J=00H vuelve al fetch; en 02H el multiplexor carga la base que da el decodificador de I2I1I0 (la microorden 02H lleva la senal de despacho). 54 microordenes - MPC de 6 bits (64 posiciones) - palabra ~34 bits. CMBR (registro buffer de la memoria de control) opcional.

📚 Teoría: Tema 5, pág. 4–6 del PDF «Tema 5 SD-II_20230215.pdf» — estructura de la UC microprogramada: MPC, memoria de control, CMBR opcional y campo de selección de condiciones que goberna el multiplexor (saltos condicionales e incondicionales). 📚 Teoría: Tema 5, pág. 9 del PDF «Tema 5 SD-II_20230215.pdf» — dimensionado: el tamaño de la memoria de control viene del nº de posiciones del microprograma, y la palabra de los campos de selección, salto y funciones de control.

Errores típicos — P3

Baremo real del problema

a) secuencia de microoperaciones del juego de instrucciones = 2,5 puntos; b) diseño de la unidad de control con estructura Multiplexor–Contador–Memoria = 1 punto. Suma 3,5 p. La errata del ADD (dice «Resta» y la ALU del propio examen no la tiene) es la única incidencia del enunciado, documentada en el recuadro.

Esquema-resumen de la metodología

  1. Leer la figura y las tablas impresas antes de escribir nada — los anchos (bus 8, direcciones 16, PC/MAR/SAR de 16 partidos en dos mitades), la tabla del PC (000 es RESET, no mantenimiento), la tabla de la ALU (no hay resta) y la tabla de la ISA con códigos y longitudes: todo lo que se hace está dictado por esas cuatro cosas.
  2. Anotar las señales reales de la figura — C0–C18 con su función (la tabla de señales del datapath) y declarar RD/WR (la memoria no las dibuja); cada microoperación del examen debe nombrar esas señales, no nombres genéricos.
  3. Fetch común en 3 ciclos y despacho desde IR — MAR ← PC en dos ciclos (C8/C7) + PC cuenta, lectura del opcode a IR (C9), y el despachador cuelga el contador por I2I1I0.
  4. Tragar las direcciones por el puente SAR — cada <dir>: MAR ← PC, leer byte alto a SRARH (C18), leer byte bajo a SRARL (C17), y MAR ← SAR (dos ciclos) para la lectura real.
  5. Montar CMAC y ADD con las funciones que sí existen — CMAC = NOT + +1; ADD = dos lecturas con Buffer de puente y dos L+R encadenadas (errata documentada).
  6. SUBR con doble destino — dir por SAR→MUX→PC (100/101) y retorno con el camino dedicado PC→SAR en el flanco del ciclo en que el bus lleva otra cosa.
  7. Dimensionar la UC y validar el microprograma ejecándolo — 54 microórdenes → MPC de 6 bits y ROM 64×~34; el modelo Python del datapath de la figura (disciplina de bus, MAR completo, IR solo tras lectura) da TRAZADA OK en 71 ciclos sobre un programa con las 7 instrucciones y caza 3 fallos típicos inyectados.

Idea transversal: aquí el trabajo del examen no es la aritmética —es casi todo arquitectura de trasvados—: con bus de 8 y registros de 16 partidos, cada dirección es un viaje de dos ciclos, y el SAR hace de puente tanto para las subrutinas como para los operandos; el verificador de disciplina de bus (un emisor por ciclo, MAR completo, IR solo tras lectura) es lo que convierte la tabla de microoperaciones en algo comprobable.

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.