Guía de resolución — Examen de Sistemas Digitales II, Diciembre 2021 (15-12-2021)
Guía modelo para preparar la convocatoria de nov-dic 2026. El examen es un único
problema de 10 puntos que suman cuatro entregas; esta guía lo organiza, como en el
resto del curso, en Problema 1 (diagrama ASM + VHDL del sistema) y Problema 2
(el mismo sistema con microcontrolador PicoBlaze: diagrama hardware + programa en
ensamblador). El sistema es un embalse del que se saca agua con un cubo: un motor
M sube y baja el cubo (M1 bajar / M2 subir), una compuerta G se abre con un impulso en
G1 y se cierra con un impulso en G2, hay un pulsador I, un sensor A de llenado (dentro
del cubo) y un sensor B de posición inicial (en lo alto de la pared, según la figura).
La hoja imprime el bloque «PicoBlaze Microcontroller» y la tabla de instrucciones en
español (más un recorte inglés de las dos filas TEST) que hay que respetar.
| Entrega del enunciado | Puntos | Dónde está en esta guía | Estado |
|---|---|---|---|
| a) Diagrama ASM del sistema | 3 | Problema 1 | publicado y verificado |
| b) Diagrama ASM en VHDL | 2 | Problema 1 | publicado y verificado |
| c) Diagrama detallado de hardware con el picoBlaze | 1,5 | Problema 2 | publicado y verificado |
| d) Programa en ensamblador para el picoBlaze | 3,5 | Problema 2 | publicado y verificado |
Estado de esta guía: publicados y verificados los cuatro apartados del examen: 1.a + 1.b (diagrama ASM y módulo VHDL 1 a 1, simulado con GHDL 4.1.0 estricto con testbench de asserts y mutaciones que caen) y 2.c + 2.d (hardware con auditoría visual de la tabla ISA impresa en la propia hoja + programa trazado con un mini-emulador). La guía está completa: 10 de 10 puntos del examen.
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, código, valores concretos).
Verificación de esta guía (2026-10-30): (1) la tabla ISA impresa en la hoja y el
símbolo del core se recuperaron con pdfimages y se transcribieron por visión en 3 bandas
× 3 pasadas (coincidentes): detalle en figuras/dic21/notas-dic21-visual-p2.md.
(2) El ensamblador del apartado d) se ciñe a esa tabla (el mini-emulador aborta
ante INPUT, OUTPUT, JP, BRANCH, RETURN, CONSTANT o s10) y está
trazado: recorre el ciclo completo dos veces más el caso de interrupción
(TRAZADA OK: 35 instrucciones, 187 pasos, 24 escrituras al puerto de salida), con
los invariantes de seguridad cumplidos, y caen las 9 variantes negativas N1–N9 de
errores típicos. (3) El SVG del hardware pasó el autocheo geométrico (GEOM OK) y la
revisión visual (LIMPIO). (4) El VHDL del apartado b) es el bloque vhdl literal del
Problema 1 y está simulado con GHDL 4.1.0 estricto (-a --std=08, sin -frelaxed)
contra un testbench que modela la mecánica y comprueba con asserts los tres escenarios
del enunciado y los enclavamientos: TEST PASSED, y tres mutaciones del diseño caen
cada una con su motivo.
Supuestos declarados (escríbelos siempre en el examen)
- Sensores (figura): el enunciado texto solo nombra el pulsador I y el sensor A («cuando el sensor A lo indica» = cubo lleno), pero la figura del examen dibuja además el sensor B pegado a la pared izquierda en lo alto: es el final de carrera de la posición inicial del cubo (el enunciado dice «subir hasta la posición inicial», y alguien tiene que detectar ese tope). Decláralo: A = cubo lleno (nivel ALTO al llenarse), B = cubo arriba del todo (nivel ALTO en posición inicial).
- Motor: la figura da las líneas M1 (BAJAR) y M2 (SUBIR) del motor M. Son niveles ALTO mantenidos mientras el motor actúa; el software debe enclavarlas: nunca M1 y M2 a la vez (requisito de seguridad que hay que escribir).
- Impulsos G1/G2 ≥ 2 ciclos de reloj: el enunciado fija que la apertura/cierre de
la compuerta se ordenan con un impulso positivo de al menos dos ciclos de reloj
(y supone apertura y cierre mecánicamente muy cortos). El ensamblador lo cumple
escribiendo dos
OUTconsecutivos al latch de salida: el 1 de G1 (o G2) permanece entre ambas escrituras un ciclo de instrucción completo (≈4 CLK del core según el Tema 4, con creces ≥ 2). Declara esa equivalencia; no hace falta ningún contador externo porque el enunciado no pone relojes ni frecuencias en el problema. - Puertos: el examen no fija ids de puerto. Decisión propia: lectura H"00" y
escritura H"01" (
PORT_IDde 8 bits del símbolo impreso da para 64 puertos: sobra). - Segunda pulsación de I en la bajada: «si se vuelve a pulsar y soltar I en el recorrido de bajada…»: el programa dispara la interrupción en cuanto I llega a nivel ALTO (no espera el soltado completo: interrumpir antes ya cumple; decláralo). La condición de llenado A se comprueba antes que I: si a la vez A=1 e I=1, el cubo está lleno y se sube normal (prioridad de A, decláralo).
- Sin interrupciones: la tabla trae
EINT/DINT/RETIpero no hace falta ninguna: los sensores se sondean conINen cada vuelta; las patillasINTERRUPTeINTERRUPT_ACKdel símbolo quedan sin conectar (decisión propia). - Arranque: «el sistema se encuentra inicialmente como se muestra en la figura»: cubo en la posición inicial (B=1), compuerta cerrada (G1=G2=0), cubo vacío (A=0).
Problema 1 — El embalse: diagrama ASM y VHDL (a = 3 p · b = 2 p)
Publicado y verificado (2026-10-30): el VHDL de b) es 1 a 1 con el ASM de a) y está simulado con GHDL 4.1.0 estricto (
--std=08, sin-frelaxed) con un testbench de asserts: los tres escenarios del enunciado pasan, los enclavamientos se comprueban ciclo a ciclo y tres mutaciones del diseño caen (ver «Verificación con GHDL» al final del apartado b).
Planteamiento. Máquina de estados con dos salidas de motor enclavadas mutuamente (M1/M2), dos salidas de compuerta en impulso temporizado (G1/G2 ≥2 CLK) y tres entradas (I, A, B). El recorrido normal es: espera de pulsar-y-soltar I → impulso G1 → bajar hasta A → parar → subir hasta B → parar → impulso G2 → vuelta a esperar. La única incidencia del enunciado es I durante la bajada: «se debe interrumpir la operación y volver a subir el cubo a la posición inicial, cerrando la compuerta» — no aborta el ciclo: el cubo sube y la compuerta se cierra igual.
Datos que fija el enunciado y decisiones de diseño. Fija el enunciado la secuencia completa («una vez que se ha pulsado y soltado el pulsador I, debe abrirse la compuerta mediante un impulso positivo en G1 al menos durante dos ciclos de reloj… luego el cubo debe bajar hasta llenarse de agua. Una vez lleno (cuando el sensor A lo indica), el cubo debe subir hasta la posición inicial y luego se debe cerrar la compuerta mediante un pulso en G2 que dure al menos dos ciclos de reloj») y la incidencia de I en la bajada. No lo fija (decisiones propias, decláralas): qué señal detecta la posición inicial (B, solo dibujado en la figura — supuesto 1 del preámbulo); si el VHDL acepta I en la bajada por nivel (se interrumpe nada más llegar I a 1, sin esperar el soltado: interrumpir antes que el «pulsar y soltar» completo también cumple, y es el mismo criterio del programa PicoBlaze de más abajo, supuesto 5); el orden cuando A e I coinciden en la misma lectura (se evalúa antes A: gana la caja de llenado — como las dos transiciones van al mismo PARO_1, la prioridad solo hace determinista la decisión); cuánto dura la parada del motor (1 CLK basta para garantizar el CLK intermedio con el motor apagado antes de invertir el sentido); y los nombres de los 6 estados. Baremo de la hoja: a) diagrama ASM: 3 p · b) VHDL: 2 p.
a) Diagrama ASM del sistema (3 puntos)
Bloques ASM (uno por estado; «contador interno» = cuenta de CLK que se lleva dentro del propio estado; «sin transición» = permanecer):
| # | Estado (bloque ASM) | Salidas | Decisiones → siguiente estado |
|---|---|---|---|
| 1 | ESPERA (cubo arriba B=1, compuerta cerrada) |
M1=0 M2=0 G1=0 G2=0 | cajas en cascada: ¿I=1? y luego ¿I=0? (pulsar y soltar) → 2 |
| 2 | PULSO_G1 |
G1=1 | contador interno cumple 2 CLK → 3 |
| 3 | BAJANDO |
M1=1 | A=1 → 4 (cubo lleno; caja evaluada primero); si no, I=1 → 4 (interrupción) |
| 4 | PARO_1 |
todo 0 (motor parado) | 1 CLK → 5 |
| 5 | SUBIENDO |
M2=1 | B=1 → 6 |
| 6 | PULSO_G2 |
G2=1 | contador interno cumple 2 CLK → 1 |
Claves del planteamiento (lo que puntúa):
- Enclavamiento M1/M2 por construcción: M1 solo está a 1 en
BAJANDOy M2 solo enSUBIENDO— nunca en el mismo estado, y entre los dos media siempre unPARO_1(1 CLK con el motor apagado antes de invertir el sentido). El motor de la figura tiene dos bobinados (M1/M2): escribir este requisito de seguridad puntúa. - G1/G2 son impulsos, no niveles: «impulso positivo en G1 al menos durante dos ciclos de reloj» (igual G2). Cada G vale 1 solo dentro de su estado, y el estado dura lo que marca un contador interno de 2 CLK. No hace falta reloj externo ni división de frecuencia: el enunciado no da frecuencias, «ciclos de reloj» son períodos del reloj del sistema.
- La incidencia no aborta el ciclo: la ruta de I en la bajada confluye en el
mismo
PARO_1que el llenado: subida hasta la posición inicial yPULSO_G2de cierre («volver a subir el cubo a la posición inicial, cerrando la compuerta»). - «Pulsar y soltar» = dos cajas de selección en cascada dentro de
ESPERA(primero se espera I=1 y luego el soltado I=0): así la espera no dispara con el botón ya pulsado. En la bajada, en cambio, I se acepta por nivel en cuanto llega a 1 (criterio declarado, coherente con el programa del apartado d). - Prioridad A antes que I en
BAJANDO: con ambas a 1 en la misma lectura gana la caja de llenado (el cubo ya está lleno: se sube normal). Las dos transiciones van aPARO_1, así que el recorrido no cambia — la prioridad hace determinista la escritura. - Sensor B: solo aparece en la figura; es el final de carrera de la «posición inicial» que el texto menciona sin nombrar la señal (supuesto declarado arriba).
Ejemplo de recorrido: reposo (B=1) →(pulsar y soltar I) PULSO_G1 2 CLK →
BAJANDO hasta A=1 → PARO_1 1 CLK → SUBIENDO hasta B=1 → PULSO_G2 2 CLK →
reposo. Con incidencia: BAJANDO →(I=1 a mitad de la bajada) PARO_1 → SUBIENDO
→ PULSO_G2 → reposo, sin haber llenado el cubo y cerrando la compuerta igual.
📚 Teoría: Tema 3, pág. 15–19 del PDF «Tema 3 SD-II_20200413.pdf» — diagramas ASM: cajas de estado (rectangular: transferencias y salidas de control dentro), cajas de selección (rombo con dos salidas: estado siguiente) y cajas de condición (comportamiento tipo Mealy); un bloque ASM equivale a un estado del diagrama de estados.
b) Diagrama ASM en VHDL (2 puntos)
El módulo es 1 a 1 con el ASM de a) — nombres de estado = nombres de los bloques
del diagrama — con la estructura de clase (Tema 3, pág. 30–32): un solo proceso
con wait until clk='1' y reset síncrono; dentro, el case recorre los estados y
cada rama escribe las salidas del estado (la memoria implícita del proceso las
conserva entre flancos), más el contador cnt del impulso de compuerta (vector con
constant PULSO := 2, el umbral del enunciado) y la señal i_vista que recuerda la
pulsación de I dentro de ESPERA.
-- Embalse (examen Dic-2021, apartado b): modulo VHDL del diagrama ASM del Problema 1
-- Nombres de estado = nombres de los bloques del ASM del apartado a)
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity Embalse is
port ( clk, reset : in std_logic;
I, A, B : in std_logic; -- I pulsador, A cubo lleno, B posicion inicial
M1, M2 : out std_logic; -- motor: M1 BAJAR / M2 SUBIR (enclavadas)
G1, G2 : out std_logic ); -- compuerta: G1 abrir / G2 cerrar (impulsos >=2 CLK)
end Embalse;
architecture asm of Embalse is
type mis_estados is (ESPERA, PULSO_G1, BAJANDO, PARO_1, SUBIENDO, PULSO_G2);
signal estado : mis_estados;
-- contador del impulso de compuerta: MOD-2 (los ">=2 CLK" del enunciado)
-- (cnt_bit=2 aunque el conteo sea 0..1: hay que poder representar PULSO+1 en la comparacion)
constant PULSO : integer := 2;
constant cnt_bit : integer := 2;
signal cnt : std_logic_vector(cnt_bit-1 downto 0);
-- memoria de "I pulsada alguna vez dentro de ESPERA" (casca "pulsar y soltar")
signal i_vista : std_logic;
begin
process
begin
wait until clk = '1';
if (reset = '1') then
estado <= ESPERA;
cnt <= (others => '0');
i_vista <= '0';
M1 <= '0'; M2 <= '0'; G1 <= '0'; G2 <= '0';
else
case estado is
when ESPERA => -- cubo arriba (B=1), compuerta cerrada
M1 <= '0'; M2 <= '0'; G1 <= '0'; G2 <= '0';
cnt <= (others => '0');
if (I = '1') then i_vista <= '1'; end if; -- "pulsada alguna vez"
if (i_vista = '1' and I = '0') then -- y ADEMAS ya soltada
estado <= PULSO_G1;
i_vista <= '0';
end if;
when PULSO_G1 =>
G1 <= '1'; M1 <= '0'; M2 <= '0'; G2 <= '0'; -- impulso de apertura (2 CLK exactos)
if (cnt + 1 >= PULSO) then estado <= BAJANDO;
else cnt <= cnt + 1;
end if;
when BAJANDO =>
M1 <= '1'; M2 <= '0'; G1 <= '0'; G2 <= '0'; -- BAJAR: A tiene prioridad sobre I
cnt <= (others => '0');
if (A = '1') then estado <= PARO_1; -- cubo lleno: parada y subida
elsif (I = '1') then estado <= PARO_1; -- interrupcion: parada, subida y cierre igual
end if;
when PARO_1 => -- 1 CLK con el motor parado antes de invertir
M1 <= '0'; M2 <= '0'; G1 <= '0'; G2 <= '0';
estado <= SUBIENDO;
when SUBIENDO =>
M2 <= '1'; M1 <= '0'; G1 <= '0'; G2 <= '0'; -- SUBIR hasta la posicion inicial
if (B = '1') then estado <= PULSO_G2; end if;
when PULSO_G2 =>
G2 <= '1'; M1 <= '0'; M2 <= '0'; G1 <= '0'; -- impulso de cierre (2 CLK exactos)
if (cnt + 1 >= PULSO) then estado <= ESPERA;
else cnt <= cnt + 1;
end if;
when others =>
estado <= ESPERA;
cnt <= (others => '0');
i_vista <= '0';
M1 <= '0'; M2 <= '0'; G1 <= '0'; G2 <= '0';
end case;
end if;
end process;
end asm;
Notas para el examen: el contador solo cuenta mientras la ASM está en un estado de
impulso (las demás ramas lo dejan a 0: el PULSO_G2 siguiente vuelve a contar
desde 0; es el contador con habilitación y borrado del Tema 2); i_vista implementa
la caja en cascada de «pulsar y soltar» sin añadir estados al ASM; cada rama when
escribe las cuatro salidas (dentro del proceso se conservan entre flancos — si una
rama no escribe G1, el impulso quedaría enganchado); el reset deja la máquina en
ESPERA con todo apagado, igual que la caja inicial del ASM. La anchura real de
cada impulso es PULSO CLK exactos (2 con el valor del examen): cumple el «al menos
dos» y es acotada — un impulso, no un nivel. Para simular a otra anchura se cambia
la constante (o se parametriza con GENERIC a la manera del antirrebote_par de
Tema 3, pág. 33–34). En el examen la cuenta va como constant dentro de la
architecture (así lo escribe el oficial: constant cont_bit : integer := 28); para
simular basta reducir esa constante, o subirla a un generic como el
antirrebote_par de clase y pasarla al instanciar el testbench.
Verificación con GHDL (pasa, y tres mutaciones del diseño caen). El bloque de
arriba se analiza con GHDL 4.1.0 (--std=08 -fsynopsys — la bandera habilita el
paquete STD_LOGIC_UNSIGNED que usan los apuntes) y se ejecuta contra un
testbench que modela la mecánica a escala (cubo de 6 posiciones: A al tocar fondo,
B arriba) y comprueba ciclo a ciclo: M1 y M2 nunca a la vez, G1 y G2 nunca a la vez,
un CLK de parada antes de invertir el motor, anchura de cada impulso G exactamente
2 CLK, y exactamente 3 impulsos G1 y 3 G2 en los tres escenarios del enunciado
(ciclo normal; I pulsada a mitad de la bajada — para antes de llenarse, sube hasta
B, cierra G2 y vuelve a ESPERA; I mantenida durante toda la bajada — gana A al
fondo y el ciclo termina normal). Salida real de la ejecución:
$ ghdl -a --std=08 -fsynopsys embalse.vhd tb_embalse.vhd
$ ghdl -r --std=08 -fsynopsys work.tb_embalse
(...) fin G1 w=2 pulses1=1 / fin G2 w=2 pulses2=1
(...) ESCENARIO 1 OK: ciclo normal, impulsos de 2 CLK exactos
(...) ESCENARIO 2 OK: interrupcion a mitad, sube y cierra sin llenar
(...) ESCENARIO 3 (I mantenida): fin G1 w=2 pulses1=3 / fin G2 w=2 pulses2=3
(...) TEST PASSED: 3 escenarios + invariantes M1/M2, G1/G2, PARO_1 y anchura 2 CLK exactos
Y para que el verificador no sea un sello de conformidad, se mutó el diseño y las
tres variantes caen cada una con motivo concreto: V1 quitar el PARO_1 (bajar →
subir directo) → «invariante violado: M2 arranca sin CLK de parada previa»; V2
suprimir la rama elsif I de la bajada → el cubo llega al fondo y salta «la
interrupcion debe parar antes de llenarse»; V3 quitar la cuenta de salida de
PULSO_G1 → la máquina no sale nunca del impulso G1 (watchdog del testbench). 3/3
caen, y el diseño original vuelve a pasar tras restaurarlo.
📚 Teoría: Tema 3, pág. 23–24 del PDF «Tema 3 SD-II_20200413.pdf» — diagrama ASM y módulo VHDL equivalente. 📚 Teoría: Tema 3, pág. 30–32 del PDF «Tema 3 SD-II_20200413.pdf» — traducción de ASM a VHDL: descripción de comportamiento estado a estado, sin estructura de componentes; a los puertos de la tarjeta identificativa del ASM hay que añadirles las señales de reloj y reset. 📚 Teoría: Tema 3, pág. 33–34 del PDF «Tema 3 SD-II_20200413.pdf» — simulación en VHDL usando parametrización: la cuenta máxima del contador se reduce para que las escalas temporales no se diferencien (aquí hace ese papel el generic G_PULSO_CLK). 📚 Teoría: Tema 2, pág. 56–58 del PDF «Tema 2 SD-II_20200317.pdf» — contador síncrono con habilitación y borrado (el contador del impulso G solo cuenta habilitado dentro de PULSO_G1/PULSO_G2 y se limpia al salir).
Errores típicos — P1
- Tratar G1/G2 como niveles mantenidos en vez de impulsos de al menos 2 CLK: el estado de impulso dura 2 CLK y la señal termina con el estado (mutación V3 arriba).
- Pasar de M1 a M2 sin el
PARO_1intermedio (mutación V1): viola el enclavamiento del motor de la figura; M1 y M2 no pueden estar nunca a la vez. - Olvidar la incidencia de I en la bajada, o interpretarla como abortar el ciclo: el enunciado obliga a subir y cerrar igualmente (mutación V2).
- No esperar el soltado de I al salir de
ESPERA(el enunciado dice «pulsar y soltar»), o no declarar los criterios: I aceptada por nivel en la bajada y prioridad A-ante-I en la misma lectura. - Inventar un temporizador o divisor externo para los 2 CLK: el enunciado no da frecuencia; «dos ciclos de reloj» son dos períodos del reloj del sistema.
- En el VHDL: nombres de estado distintos de los del ASM (se pierde el «Diagrama ASM en VHDL» 1 a 1), olvidar los valores por defecto del proceso combinacional (latch inferido), o no añadir reloj y reset a la entidad, que el ASM no dibuja pero el Tema 3 exige (pág. 30).
Problema 2 — El mismo embalse con PicoBlaze: hardware y programa (1,5 + 3,5 puntos)
El apartado c) pide el diagrama detallado de hardware con el picoBlaze (1,5 p) y
el d) el programa en ensamblador para el picoBlaze (3,5 p). La hoja imprime el
símbolo del core y la tabla de instrucciones en español (con un recorte inglés de las
filas TEST) que se transcriben verbatim en el apartado c.
a) Diagrama ASM del sistema (3 p) y b) VHDL (2 p) — ver Problema 1
Publicados y verificados arriba, en el Problema 1 (ASM + VHDL simulado con GHDL estricto). El programa del apartado d) es la traducción 1 a 1 de esos 6 bloques ASM (espera del pulsador, impulso G1, bajada, paro, subida, impulso G2), con las etiquetas del ASM.
Datos que fija el enunciado y decisiones de diseño
Fija el enunciado: el sistema completo y sus nombres de señal — pulsador I,
sensor de llenado A (en el cubo, la figura), sensor de posición inicial B (lo
alto de la pared izquierda, la figura), motor M con M1 (BAJAR) y M2
(SUBIR), compuerta G con G1 Abrir / G2 Cerrar —; la secuencia completa de
comportamiento (pulsar y soltar I → G1 ≥2 CLK → bajar hasta A → subir a posición
inicial → G2 ≥2 CLK; I en la bajada → parar, subir y cerrar) y la restricción de que
los impulsos de compuerta duren al menos dos ciclos de reloj. No lo fija: los
ids y mapas de bits de los puertos (decisión propia H"00"/H"01" declarada), qué señal
detecta la posición inicial (B según la figura, supuesto declarado), cómo se
garantizan los ≥2 CLK con software (dos OUT consecutivos al latch = 1 ciclo de
instrucción ≈4 CLK ≥2), el sondeo en vez de interrupción (decisión propia) y la
prioridad A-sobre-I en la misma lectura (supuesto declarado).
c) Diagrama detallado de hardware con el picoBlaze (1,5 puntos)

Auditoría de la tabla ISA impresa en la hoja (hazla antes de ensamblar)



La tabla está impresa en la propia hoja (esquina inferior derecha; imagen incrustada
en el PDF: pdfimages → img-005) con encabezado «Instrucción | Comentario» y las
«Instrucciones» subdivididas en 4 subcolumnas. Transcripción verbatim (3 bandas × 3
pasadas de visión, en figuras/dic21/notas-dic21-visual-p2.md):
| «Comentario» de la hoja | Instrucción |
|---|---|
| «Operaciones sin y con acarreo (finalizadas en C)» | ADD sX,sY · ADD sX,kk · ADDC sX,sY · ADDC sX,kk — SUB sX,sY · SUB sX,kk · SUBC sX,sY · SUBC sX,kk |
| «Desplazamientos introduciendo un 0, 1, el último elemento y el bit de acarreo» | SL0 sX · SL1 sX · SLX sX · SLA sX — SR0 sX · SR1 sX · SRX sX · SRA sX (la «0» es cero, no letra O) |
| «Rotación» | RL sX · RR sX |
| «Instrucciones lógicas» | AND sX,sY · AND sX,kk · OR… · XOR… |
| «Instrucciones de verificación» | COMP sX,sY · COMP sX,kk · TEST sX,sY · TEST sX,kk |
| «Movimiento de registros» | LOAD sX,sY · LOAD sX,kk |
| «Operaciones con puertos» | IN sX,(sY) · IN sX,kk — OUT sX,(sY) · OUT sX,kk |
| «Operaciones con memoria» | FETCH sX,(sY) · FETCH sX,kk — STORE sX,(sY) · STORE sX,kk |
| «Instrucciones de saltos» | JUMP etiq · JUMP (N)Z,etiq · JUMP (N)C,etiq — CALL igual — RET |
| «Habilitación Y deshabilitación de interrupciones» | EINT · DINT y RETI (RETI con celda combinada) |
Además, en la esquina inferior IZQUIERDA de la misma hoja hay un recorte en inglés
(encabezado con borde rojo y errata «Fuction») con las dos filas TEST:
TEST sX,kk / TEST sX,sY — «Test bits in register sX against literal kk. Update
CARRY and ZERO flags. Registers are unaffected.», función: «If (sX AND kk)=0,
ZERO←1; CARRY← odd parity of (sX AND kk)» (columnas ZERO/CARRY con «?»: las banderas
las fija la columna Function).
Lo que hay que sacar de la tabla antes de escribir el programa:
- Registros solo s0–sF (16×8). La constante es el inmediato
kk(en el ensamblador del curso se escribeH"04"; elk'04'de KCPSM6 no está en la tabla). OUT sX,kkescribe el CONTENIDO desXen el puertokk: el dato va primero y el puerto después (igual que en octubre-2023; para sacar una constante: primeroLOAD s1,H"xx"y luegoOUT s1,puerto). No existeCONSTANT.TEST sX,kkhace AND sin guardar (lo dice el recorte inglés: «Registers are unaffected») y actualiza banderas: Z=1 si el AND da 0; C=paridad.COMPigual sin guardar. Los saltos condicionales salen de(N)Zy(N)C: solo Z/NZ y C/NC.- No existen (no vale escribirlos):
INPUT,OUTPUT,JP,BRANCH,RETURN(la tabla diceRET),CONSTANTy condicionesCC/CS. En esta hoja los nombres sonIN/OUT/JUMP/RET: responder con el juego de KCPSM6 es responder con instrucciones que el examen no da. - La tabla sí trae
FETCH/STORE(RAM scratchpad) yEINT/DINT/RETI, pero no los uso: el programa es plano y sondea conIN;INTERRUPTeINTERRUPT_ACKquedan sin conectar. - El símbolo impreso del core: izquierda
IN_PORT[7:0],INTERRUPT,RESET,CLK(con triángulo); derechaOUT_PORT[7:0],PORT_ID[7:0],READ_STROBE,WRITE_STROBE,INTERRUPT_ACK.PORT_IDde 8 bits: sobra espacio para H"00" y H"01".
Mapa de puertos y EQU (decláralos en el examen)
| Puerto | Direcc. | Bits |
|---|---|---|
P_ENT (entrada, se carga con READ_STROBE) |
00H | bit0=I (pulsador) · bit1=A (cubo lleno) · bit2=B (posición inicial) |
P_SAL (salida, latch con WRITE_STROBE) |
01H | bit0=M1 (BAJAR) · bit1=M2 (SUBIR) · bit2=G1 (abrir) · bit3=G2 (cerrar) |
Máscaras derivadas: I=H"01", A=H"02", B=H"04"; M1=H"01", M2=H"02",
G1=H"04", G2=H"08". Las salidas de control de la compuerta se escriben como
pulsos: H"04"→H"00" (G1) y H"08"→H"00" (G2).
Diagrama lógico (descríbelo/dibújalo — parte del 1,5 p)
- Núcleo PicoBlaze en el centro: fichero de registros s0–sF (16×8), ALU de 8 bits
con banderas Z/C, PC de 10 bits, bus de direcciones de ROM A9–A0 y palabra de
instrucción de 18 bits, buses de E/S
IN_PORT/OUT_PORTde 8 bits,PORT_IDde 8 bits y strobesREAD_STROBE/WRITE_STROBE(los pines del símbolo impreso). - ROM de programa 1024×18: bloque RAM de la FPGA con
WEfijo a 0 (Tema 4 p45); posición 03FFH =RETI(sin usar). El programa del apartado d) son 35 instrucciones. - Reloj al
CLKdel core. El enunciado no da frecuencia y no hace falta ningún contador externo: la única temporización fija son los impulsos G1/G2 ≥2 CLK y los produce el propio core al escribir dosOUTconsecutivos (≈4 CLK entre escrituras). - Entradas I (pulsador con su acondicionado, nivel ALTO al pulsar), A (cubo lleno)
y B (posición inicial) → registro
P_ENTH"00". SalidasP_SALH"01": bit0/bit1 → etapa de potencia del motor M (M1=bajar, M2=subir; el software jamás las activa a la vez ni invierte sin pasar por parado); bit2/bit3 → actuador de la compuerta G (G1=impulso de apertura, G2=impulso de cierre). - Decodificación de puertos: con
PORT_ID+ strobes se seleccionan H"00" (carga conREAD_STROBE, sale porIN_PORT) y H"01" (latch conWRITE_STROBE: mantiene lo escrito hasta la siguiente escritura — así se forman los pulsos G1/G2 por software). INTERRUPTeINTERRUPT_ACKquedan sin conectar (sondeo puro).
Diagrama verificado con el que responder (pines del core = el símbolo impreso):
d) Programa en ensamblador para el picoBlaze (3,5 puntos)
Cada bloque del ASM del apartado a) se traduce a un bloque de ensamblador con su etiqueta y el mismo orden de comprobaciones (primero la condición de salida del bloque, después la incidencia):
ASM 1 ESPERA -> INICIO/ESP_I/SUE_I (pulsar y soltar I; latch de salida a 0)
ASM 2 PULSO_G1 -> G1PUL (dos OUT: G1=1 y luego G1=0; >= 2 ciclos de reloj)
ASM 3 BAJANDO -> BAJAR/BAJ_L (M1=1; prueba A con prioridad, luego I)
ASM 4 PARO_1 -> PARO (motor parado en la pausa de inversion)
ASM 5 SUBIENDO -> SUBIR/SUB_L (M2=1 hasta B)
ASM 6 PULSO_G2 -> PARO2/G2PUL (dos OUT: G2=1 y luego G2=0; >= 2 ciclos)
; =====================================================================
; Embalse (diciembre-2021, apartados c y d): micro PicoBlaze + logica de E/S
; Unicos mnemonicos validos: los de la tabla ISA impresa en la propia hoja
; (auditada por vision, ver notas visuales). Aqui se usan LOAD, IN, OUT,
; TEST y JUMP (etiq, Z y NZ). EQU y ORG son directrices del ensamblador,
; no instrucciones de la tabla.
;
; Puerto lectura H"00" (P_ENT): bit0=I (pulsador) bit1=A (cubo lleno)
; bit2=B (cubo en posicion inicial)
; Puerto escritura H"01" (P_SAL, latch): bit0=M1 (BAJAR) bit1=M2 (SUBIR)
; bit2=G1 (abrir compuerta) bit3=G2 (cerrar compuerta)
; =====================================================================
P_ENT EQU H"00"
P_SAL EQU H"01"
ORG H"000"
; ---------------------------------------------------------------------
; BLOQUE 1: ESPERA DE PULSAR Y SOLTAR I (cubo arriba, compuerta cerrada)
; ---------------------------------------------------------------------
INICIO: LOAD s1, H"00" ; latch a 0: motor parado, compuerta sin pulso
OUT s1, P_SAL ; asegurado al arrancar
ESP_I: IN s0, P_ENT ; leo I, A y B en un solo byte
TEST s0, H"01" ; pruebo I (bit0): Z=1 mientras I este a 0
JUMP Z, ESP_I ; aun no pulsado: sigo en la espera
SUE_I: IN s0, P_ENT ; I a 1: espero el SOLTADO (pulsar y soltar I)
TEST s0, H"01"
JUMP NZ, SUE_I ; mientras siga pulsado: sigo esperando
; ---------------------------------------------------------------------
; BLOQUE 2: IMPULSO POSITIVO EN G1 (abrir; >= 2 ciclos de reloj)
; ---------------------------------------------------------------------
G1PUL: LOAD s1, H"04" ; G1=1: orden de abrir la compuerta
OUT s1, P_SAL ; el 1 queda en el latch de salida
LOAD s1, H"00" ; G1=0: fin del impulso (compuerta abierta)
OUT s1, P_SAL ; el 1 ha durado 2 ciclos de instruccion >= 2 CLK
; ---------------------------------------------------------------------
; BLOQUE 3: BAJAR EL CUBO HASTA LLENARSE (M1=1; A con prioridad)
; ---------------------------------------------------------------------
BAJAR: LOAD s1, H"01" ; M1=1 (BAJAR): el resto de salidas a 0
OUT s1, P_SAL
BAJ_L: IN s0, P_ENT ; relectura de sensores en cada vuelta
TEST s0, H"02" ; pruebo A (bit1): cubo lleno
JUMP NZ, PARO ; A=1: lleno -> para el motor y sube
TEST s0, H"01" ; pruebo I (bit0): I pulsada en la bajada
JUMP NZ, PARO ; interrupcion: sube y cierra igualmente
JUMP BAJ_L ; sigo bajando
; ---------------------------------------------------------------------
; BLOQUE 4: PARO DEL MOTOR antes de invertir el sentido
; ---------------------------------------------------------------------
PARO: LOAD s1, H"00" ; M1=0, M2=0: motor parado en la pausa
OUT s1, P_SAL
; ---------------------------------------------------------------------
; BLOQUE 5: SUBIR HASTA LA POSICION INICIAL (M2=1 hasta B)
; ---------------------------------------------------------------------
SUBIR: LOAD s1, H"02" ; M2=1 (SUBIR): el resto de salidas a 0
OUT s1, P_SAL
SUB_L: IN s0, P_ENT ; relectura en cada vuelta
TEST s0, H"04" ; pruebo B (bit2): cubo de vuelta arriba
JUMP NZ, PARO2 ; B=1: posicion inicial alcanzada
JUMP SUB_L ; sigo subiendo
; ---------------------------------------------------------------------
; BLOQUE 6: PARO E IMPULSO EN G2 (cerrar; >= 2 ciclos de reloj)
; ---------------------------------------------------------------------
PARO2: LOAD s1, H"00" ; motor parado asegurado
OUT s1, P_SAL
G2PUL: LOAD s1, H"08" ; G2=1: orden de cerrar la compuerta
OUT s1, P_SAL
LOAD s1, H"00" ; G2=0: fin del impulso
OUT s1, P_SAL
JUMP INICIO ; ciclo completo: vuelta a esperar I
Cómo leerlo, línea a línea. INICIO deja el latch de salida a 0 (motor parado y
compuerta sin pulso: el estado de la figura). ESP_I sondea I y salta mientras I=0
(TEST H"01" + JUMP Z); SUE_I espera el soltado (salta mientras I sigue a 1:
JUMP NZ) — el enunciado dice «pulsar y soltar I». G1PUL: dos OUT — el 1 de
G1 queda en el latch entre ambos y dura un ciclo de instrucción completo (≈4 CLK ≥
2 CLK: decláralo). BAJ_L relee sensores en cada vuelta y prueba primero A
(prioridad: si a la vez A=1 e I=1 se sube normal) y después I (interrupción); las dos
rutas caen en PARO porque el enunciado exige «parar, volver a subir y cerrar» tanto
si está lleno como si se interrumpe. PARO/PARO2 garantizan el motor parado antes
de invertir el sentido (enclavamiento). G2PUL cierra con su impulso y JUMP INICIO
reinicia el ciclo. Solo se usan LOAD, IN, OUT, TEST y JUMP (etiq, Z y NZ) de
la tabla de la hoja; EQU y ORG son directrices del ensamblador, no instrucciones.
Verificación con mini-emulador (pasa, y las negativas caen)
El bloque asm de arriba se ejecuta en un mini-emulador (Python) que: (1)
implementa la tabla impresa y aborta ante INPUT, OUTPUT, JP, BRANCH,
RETURN, CONSTANT, condiciones CC/CS o registros fuera de s0..sF; (2) modela
la mecánica (cubo que sube/baja con M1/M2 hasta A/B, compuerta que abre con flanco de
G1 y cierra con flanco de G2, pulsador por nivel con ventanas de pulsación, a escala
simbólica como en los testbench GHDL del curso) y (3) comprueba el trazado exacto
contra asserts. Resultado real de la ejecución (3 ciclos: normal, con interrupción de
I en la bajada, y normal otra vez):
TRAZADA OK — 35 instrucciones, 187 pasos; 24 escrituras al puerto de salida con la secuencia exacta [G1=1, 0, M1=1, 0, M2=1, 0, G2=1, 0]×3; las paradas de la bajada se motivan A, I, A en el orden esperado; los impulsos G1/G2 miden su anchura entre escrituras y cumplen ≥2 CLK (un ciclo de instrucción ≈4 CLK); M1/M2 y G1/G2 nunca estuvieron simultáneas; hubo siempre escritura intermedia de parada entre bajar y subir; y la compuerta estaba abierta antes de cada bajada.
Y para que el verificador no sea un sello de conformidad, se ejecutan 9 mutaciones
(cada una un error típico, generadas con sed sobre el ensamblador): N1 probar B
en vez de A en la bajada · N2 saltarse el impulso G1 (bajar con compuerta cerrada)
· N3 borrar el bloque PARO (inversión directa del motor) · N4 esperar B al
revés (JUMP Z en vez de JUMP NZ en SUB_L) · N5 cerrar escribiendo H"10" en vez
de H"08" · N6 escribir s10 (fuera de s0–sF) · N7 escribir INPUT (mnemónico
fuera de la tabla) · N8 no esperar el soltado de I (JUMP Z en SUE_I) · N9
probar A en vez de I al detectar la interrupción. Las 9 caen en los asserts o en
el control de tabla, cada una con motivo concreto de fallo. Reproducción:
python3 emu_dic21_p2.py GUIA.md — el mini-emulador extrae solo el bloque asm del
markdown (modo guía), igual que en octubre-2023 y junio-2024.
📚 Teoría: Tema 4, pág. 45 del PDF «Tema 4 SD-II_20220512.pdf» — el programa se aloja en un bloque de RAM de la FPGA (el modelo rom_1024x18 con WE a 0: el micro lee instrucciones como una ROM más)
📚 Teoría: Tema 4, págs. 34–35 del PDF «Tema 4 SD-II_20220512.pdf» — conexión de las salidas OUT a la lógica de la FPGA y uso de declaraciones EQU para nombrar los puertos de salida
📚 Teoría: Tema 4, pág. 37 del PDF «Tema 4 SD-II_20220512.pdf» — la única entrada de interrupción y las instrucciones EINT/DINT (aquí no hace falta interrupción: los sensores se sondean con IN)
📚 Teoría: Tema 4, pág. 30 del PDF «Tema 4 SD-II_20220512.pdf» — las instrucciones JUMP, CALL y RETURN dependen del valor de los flags ZERO y CARRY (por eso valen en la hoja las condiciones (N)Z y (N)C)
Errores típicos P2.c/P2.d
- Responder con mnemónicos de KCPSM6:
INPUT/OUTPUT,JP,BRANCH,CONSTANT,RETURN,k'04', condicionesCC/CS. Esta hoja imprimeIN/OUT,JUMP etiqueta,JUMP (N)Z,etiq/JUMP (N)C,etiq,LOAD sX,H"xx"yRET: usar el otro juego es responder con instrucciones que el examen no da (el emulador las rechaza). - Invertir el
OUT: en la tabla de la hoja el dato va primero —OUT s1,P_SALescribe el contenido de s1 en el puerto H"01";OUT puerto,s1está al revés. - No esperar el soltado de I en
SUE_I: el enunciado dice «pulsar y soltar», y sin esa espera la orden de arranque se dispara con I aún pulsada (caída N8). - Puentar la parada del motor: pasar de M1 a M2 sin escribir
H"00"intermedio (N3) viola el enclavamiento; M1 y M2 nunca pueden estar a la vez (assert N6-style del emulador). - Omitir el impulso G1 antes de bajar (N2) o el G2 tras la interrupción: el enunciado fija ambos; tras la interrupción de I hay que subir y cerrar.
- El impulso G1/G2 sin medir el tiempo: hay que declarar que entre las dos
escrituras al latch pasa un ciclo de instrucción ≈4 CLK ≥ 2 CLK exigidos; un solo
OUTmanteniendo el 1 sería un nivel, no un impulso. - Olvidar la relectura de sensores en cada vuelta (el
INva DENTRO de los bucles BAJ_L/SUB_L) o no probar I durante la bajada (regla de interrupción del enunciado). - No declarar qué señal detecta la posición inicial: B solo sale en la figura; sin ese supuesto el «subir hasta la posición inicial» no tiene cómo terminar.
- Priorizar mal la doble condición A/I en la misma lectura de
BAJ_L(declara A primero) o no escribir el enclavamiento M1/M2 como requisito de seguridad. EQU/ORGcomo si fueran instrucciones,s10como registro, o usarEINTpara el sondeo sin justificarlo (aquí sobran: tabla traeEINT/DINT/RETIy no hace falta).
Esquema-resumen de la metodología (Problema 2)
- Leer la figura con atención: fija nombres de señal (I, A, B, M, M1/M2, G1/G2) que el texto no repite — el sensor B de posición inicial solo está dibujado.
- Auditar la tabla ISA impresa antes de programar (
pdfimages+ 3×3 pasadas): aquí los mnemónicos sonIN/OUT/RET/JUMP, el dato delOUTva primero y solo hay condiciones Z/C. - Fijar puertos y EQU con tabla de bits escrita ANTES del programa; todo
TEST/LOADse deriva de ese mapa. - Dibujar el hardware: core con los pines del símbolo impreso + ROM 1024×18 (RAM FPGA, WE a 0) + decodificación de puertos + etapa de potencia del motor y actuador de compuerta; reloj solo al core (sin contadores externos si no hay tiempos largos).
- Traducir los bloques ASM 1 a 1 con etiquetas, y respetar «pulsar y soltar», la prioridad A, la parada del motor y los pulsos de compuerta temporizados.
- Verificar: secuenciador físico + asserts de invariantes (enclavamiento, paradas, anchura ≥2 CLK de los impulsos) sobre el bloque asm literal, y mutaciones que caen.
Resumen de baremo y tiempos recomendados (120 min)
| Apartado | Puntos | Tiempo |
|---|---|---|
| a) ASM (6 estados + incidencias) | 3 | 30 min |
| b) VHDL del ASM | 2 | 25 min |
| c) Hardware picoBlaze (simbolo + ROM + puertos + motor/compuerta) | 1,5 | 20 min |
| d) Programa ensamblador (6 bloques traducidos, comentado) | 3,5 | 45 min |
Las cuatro entregas son el MISMO sistema: si el ASM del apartado a) está bien, el VHDL y el ensamblador se deducen 1 a 1; el diagrama hardware se plantearía primero porque fija el mapa de puertos que usa el programa.