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)

  1. 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).
  2. 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).
  3. 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 OUT consecutivos 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.
  4. Puertos: el examen no fija ids de puerto. Decisión propia: lectura H"00" y escritura H"01" (PORT_ID de 8 bits del símbolo impreso da para 64 puertos: sobra).
  5. 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).
  6. Sin interrupciones: la tabla trae EINT/DINT/RETI pero no hace falta ninguna: los sensores se sondean con IN en cada vuelta; las patillas INTERRUPT e INTERRUPT_ACK del símbolo quedan sin conectar (decisión propia).
  7. 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
stateDiagram-v2 [*] --> ESPERA : arranque (B=1, cerrada, vacio) ESPERA --> PULSO_G1 : I pulsada y soltada PULSO_G1 --> BAJANDO : cumplidos 2 CLK de G1 BAJANDO --> PARO_1 : A=1 (lleno, prioridad) o I=1 (interrupcion) PARO_1 --> SUBIENDO : motor parado SUBIENDO --> PULSO_G2 : B=1 (posicion inicial) PULSO_G2 --> ESPERA : cumplidos 2 CLK de G2

Claves del planteamiento (lo que puntúa):

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 del curso: un proceso secuencial (registro de estado + contador de los impulsos G + memoria i_vista de la segunda caja «soltar I») y un proceso combinacional con valores por defecto (salidas + estado siguiente). El generic G_PULSO_CLK := 2 es el umbral de ciclos del impulso: en el examen se escribe el 2 directamente; el generic solo sirve para simular a otra escala.

-- 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;

entity Embalse is
    generic (
        G_PULSO_CLK : integer range 2 to integer'high := 2  -- anchura de los impulsos G1/G2 en CLK (>=2 por enunciado)
    );
    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 entity Embalse;

architecture ASM of Embalse is
    -- nombres de estado = nombres de los bloques del diagrama ASM
    type t_estado is (ESPERA, PULSO_G1, BAJANDO, PARO_1, SUBIENDO, PULSO_G2);
    signal estado, siguiente : t_estado := ESPERA;

    -- contador del impulso de compuerta (cuenta solo en PULSO_G1 / PULSO_G2 y se limpia al salir)
    signal cnt    : integer range 0 to G_PULSO_CLK - 1 := 0;
    signal cnt_ok : std_logic := '0';

    -- memoria de "I estado pulsada alguna vez dentro de ESPERA" (para la casca
    -- "pulsar y soltar": la transicion exige i_vista=1 y ademas I=0)
    signal i_vista : std_logic := '0';
begin
    ------- contador de los impulsos G1/G2 -------
    process(clk)
    begin
        if rising_edge(clk) then
            if estado /= PULSO_G1 and estado /= PULSO_G2 then
                cnt <= 0; cnt_ok <= '0';           -- limpio al no estar en un estado de impulso
            elsif cnt = G_PULSO_CLK - 1 then
                cnt_ok <= '1';                     -- ya han pasado G_PULSO_CLK CLK con G=1
            else
                cnt <= cnt + 1;
            end if;
        end if;
    end process;

    ------- memoria de la pulsacion de I en ESPERA -------
    process(clk)
    begin
        if rising_edge(clk) then
            if estado = ESPERA then
                if I = '1' then i_vista <= '1'; end if;
            else
                i_vista <= '0';                    -- fuera de ESPERA no acumula pulsaciones
            end if;
        end if;
    end process;

    ------- proceso secuencial: registro del estado -------
    process(clk)
    begin
        if rising_edge(clk) then
            if reset = '1' then estado <= ESPERA;
            else                estado <= siguiente;
            end if;
        end if;
    end process;

    ------- proceso combinacional: salidas + siguiente estado -------
    process(estado, I, A, B, cnt_ok, i_vista)
    begin
        M1 <= '0'; M2 <= '0'; G1 <= '0'; G2 <= '0';  -- valores por defecto (evitan latches)
        siguiente <= estado;

        case estado is
            when ESPERA =>                          -- cubo arriba (B=1), compuerta cerrada
                if i_vista = '1' and I = '0' then   -- I pulsada Y soltada
                    siguiente <= PULSO_G1;
                end if;
            when PULSO_G1 =>
                G1 <= '1';                          -- impulso de apertura (>=2 CLK con el contador)
                if cnt_ok = '1' then siguiente <= BAJANDO; end if;
            when BAJANDO =>
                M1 <= '1';                          -- BAJAR: A tiene prioridad sobre I
                if A = '1' then       siguiente <= PARO_1;   -- cubo lleno: parada y subida
                elsif I = '1' then    siguiente <= PARO_1;   -- interrupcion: parada, subida y cierre igual
                end if;
            when PARO_1 =>                          -- 1 CLK con el motor parado antes de invertir
                siguiente <= SUBIENDO;
            when SUBIENDO =>
                M2 <= '1';                          -- SUBIR hasta la posicion inicial
                if B = '1' then siguiente <= PULSO_G2; end if;
            when PULSO_G2 =>
                G2 <= '1';                          -- impulso de cierre (>=2 CLK con el contador)
                if cnt_ok = '1' then siguiente <= ESPERA; end if;
        end case;
    end process;
end architecture ASM;

Notas para el examen: el contador solo cuenta mientras la ASM está en un estado de impulso (se limpia al salir: el PULSO_G2 del mismo ciclo 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; los valores por defecto del proceso combinacional evitan latches; el reset es opcional (el ASM no lo pide) y solo deja la máquina en ESPERA, que ya es su valor inicial. La anchura real de cada impulso es G_PULSO_CLK CLK exactos (2 con el valor del examen): cumple el «al menos dos» y es acotada — un impulso, no un nivel.

Verificación con GHDL (pasa, y tres mutaciones del diseño caen). El bloque de arriba se analiza con GHDL 4.1.0 estricto (sin -frelaxed) 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 entre 2 y 3 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; A e I simultáneas en el fondo — gana A y el ciclo termina normal). Salida real de la ejecución:

$ ghdl -a --std=08 embalse.vhd tb_embalse.vhd        # analisis estricto, sin -frelaxed
$ ghdl --elab-run --std=08 work.tb_embalse           # (un -r pelado leeria work-obj93.cf)
tb_embalse.vhd:137:9:@51ns:(report note): ESCENARIO 1: ciclo completo normal
tb_embalse.vhd:147:9:@671ns:(report note): ESCENARIO 2: I pulsada a mitad de la bajada (interrupcion)
tb_embalse.vhd:162:9:@1171ns:(report note): ESCENARIO 3: A e I coincidentes en la bajada (prioridad A)
tb_embalse.vhd:184:9:@1811ns:(report note): TEST PASSED: ciclo normal + interrupcion I en bajada + prioridad A/I; invariantes M1/M2, G1/G2, parada intermedia y anchura de impulsos G >=2 CLK todos cumplidos (3 impulsos G1 y 3 impulsos G2 registrados)

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


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)

Bloque «PicoBlaze Microcontroler» impreso en la hoja: el símbolo saca IN_PORT/OUT_PORT y PORT_ID de 8 bits, READ/WRITE_STROBE, INTERRUPT/INTERRUPT_ACK, RESET y CLK.
Bloque «PicoBlaze Microcontroler» impreso en la hoja: el símbolo saca IN_PORT/OUT_PORT y PORT_ID de 8 bits, READ/WRITE_STROBE, INTERRUPT/INTERRUPT_ACK, RESET y CLK.

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

Primera banda de la tabla de instrucciones impresa en el examen (imagen nativa del PDF, ampliada al triple): ISA en español con OUT dato-primero.
Primera banda de la tabla de instrucciones impresa en el examen (imagen nativa del PDF, ampliada al triple): ISA en español con OUT dato-primero.
Segunda banda de la tabla impresa: LOAD, IN/OUT indirectas con (sY) y saltos condicionados (N)Z/(N)C.
Segunda banda de la tabla impresa: LOAD, IN/OUT indirectas con (sY) y saltos condicionados (N)Z/(N)C.
Tercera banda de la tabla impresa: CALL/RET y EINT/DINT/RETI; sin INPUT ni RETURN ni CONSTANT.
Tercera banda de la tabla impresa: CALL/RET y EINT/DINT/RETI; sin INPUT ni RETURN ni CONSTANT.

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:

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)

  1. 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_PORT de 8 bits, PORT_ID de 8 bits y strobes READ_STROBE/WRITE_STROBE (los pines del símbolo impreso).
  2. ROM de programa 1024×18: bloque RAM de la FPGA con WE fijo a 0 (Tema 4 p45); posición 03FFH = RETI (sin usar). El programa del apartado d) son 35 instrucciones.
  3. Reloj al CLK del 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 dos OUT consecutivos (≈4 CLK entre escrituras).
  4. Entradas I (pulsador con su acondicionado, nivel ALTO al pulsar), A (cubo lleno) y B (posición inicial) → registro P_ENT H"00". Salidas P_SAL H"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).
  5. Decodificación de puertos: con PORT_ID + strobes se seleccionan H"00" (carga con READ_STROBE, sale por IN_PORT) y H"01" (latch con WRITE_STROBE: mantiene lo escrito hasta la siguiente escritura — así se forman los pulsos G1/G2 por software).
  6. INTERRUPT e INTERRUPT_ACK quedan sin conectar (sondeo puro).

Diagrama verificado con el que responder (pines del core = el símbolo impreso):

Esquema hardware PicoBlaze del embalse (diciembre-2021, apartados c y d) ROM de programa 1024 x 18 RAM de bloque FPGA, WE a 0 (Tema 4, p.45) palabra 03FFH = RETI (sin usar) ADDRESS[9:0] instruccion I[17:0] PicoBlaze Microcontroller (simbolo impreso en la hoja del examen) IN_PORT[7:0] INTERRUPT RESET CLK OUT_PORT[7:0] PORT_ID[7:0] READ_STROBE WRITE_STROBE INTERRUPT_ACK IN_PORT[7:0] reset FPGA sin uso (sondeo) OUT_PORT PORT_ID DEC:00-01 PORT_ENT H"00" bit0 I (pulsador) bit1 A (cubo lleno) bit2 B (posicion inicial) registro de E/S: se carga con PORT_ID=H"00" y READ_STROBE a 1 (IN) I pulsador nivel ALTO A: cubo lleno sensor en el cubo B: arriba pos. inicial (en la hoja) PORT_SAL H"01" bit0 M1 · bit1 M2 (motor) bit2 G1 · bit3 G2 (compuerta) latch: valor retenido Motor M del cubo M1: BAJAR el cubo M2: SUBIR el cubo nunca M1=M2=1 (software) Compuerta G del embalse G1: impulso de APERTURA G2: impulso de CIERRE impulso mas largo de 2 CLK Cubo y nivel el cubo (figura) A y B van a P_ENT Reloj del sistema CLK del core (Tema 4, p.37) Pines del core = la figura impresa en la hoja: IN_PORT/OUT_PORT y PORT_ID de 8 bits + strobes + INTERRUPT/INTERRUPT_ACK (2 ids: H"00" y H"01"). INTERRUPT e INTERRUPT_ACK quedan sin usar: los sensores se sondean por software (decision propia declarada; EINT/DINT/RETI de la tabla sobran). Sin contador externo: la unica temporizacion fija es el impulso G1/G2 (mas de 2 ciclos de reloj del core; con 4 CLK por instruccion sobra de sobra).

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

Esquema-resumen de la metodología (Problema 2)

  1. 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.
  2. Auditar la tabla ISA impresa antes de programar (pdfimages + 3×3 pasadas): aquí los mnemónicos son IN/OUT/RET/JUMP, el dato del OUT va primero y solo hay condiciones Z/C.
  3. Fijar puertos y EQU con tabla de bits escrita ANTES del programa; todo TEST/LOAD se deriva de ese mapa.
  4. 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).
  5. 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.
  6. 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.

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.