Guía de resolución — Examen de Sistemas Digitales II, Septiembre 2022 (9/9/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 3,5 (ASM 2 + VHDL 1,5) Control de proceso de mezcla de producto y agua: válvula V2 (agua, 10 s), válvula V1 (producto hasta peso P), compuerta con motor C (5 s), motor M (10 s); reloj 10 MHz
2 3,5 (hardware 1 + ensamblador 2,5) El mismo proceso con microcontrolador picoBlaze (reloj 50 MHz y contadores externos C10s y C5s con CLK, Reset, INICIO_CUENTA y Fin_de_cuenta_10s/5s; el examen incorpora la tabla de instrucciones y el bloque KCPSM3)
3 3,0 Mapa de memoria de CPU de 8 bits de datos y 16 de direcciones, más ampliación de 8 KB de ROM

Estado de esta guía: 3 de 3 problemas publicados (resueltos y verificados). El Problema 1 (ASM + VHDL del proceso de mezcla) está reescrito al estilo VHDL de clase (proceso único con wait until, reset síncrono obligatorio) y verificado con GHDL --std=08 -fsynopsys en dos escalas de pre-escala con duraciones exactas contadas en flancos.

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. Lectura de la figura (datos del subsistema, partes a–d). El único enunciado gráfico del subsistema es la figura incrustada en el PDF, verificada pin por pin en dos pasadas de zoom sobre la imagen nativa y crops a 300 dpi: decodificador DEC 2–4 con select pin «1» = A15 y pin «0» = A14 (salidas Y0…Y3 activas a nivel ALTO); Y0 e Y1 pasan por una OR a la CS de M1; Y2 entra en una AND cuya otra entrada es A13 con barra — NOT(A13) — y su salida es la CS de M2; Y3 queda suelta, sin conectar; las CS de M1 y M2 están dibujadas sin burbuja (activas a nivel ALTO, coherente con la CS ALTA de la ROM pedida); la línea R/W̄ es global y va a ambos módulos. Adoptar la barra de A13 tal como está dibujada es clave: sin ella el mapa entero cambiaría (ver «Errores típicos»).
  2. Capacidad de los módulos de la figura. La figura no rotula la capacidad de M1 y M2; sale de sus pines de dirección: M1 recibe el bus A14–A0 (anotación /15) → 2¹⁵ = 32 K×8; M2 recibe A12–A0 (anotación /13) → 2¹³ = 8 K×8. El contraste con las CS del decodificador es exacto (cada módulo ocupa justo su rango, sin aliasing), lo que confirma la lectura de la figura.
  3. Estructura de la decodificación de la ROM (parte d). El enunciado no impone circuitos: la guía reutiliza la salida libre Y3 y la gating ·A13 como enable común de un segundo DEC 2–4 sobre A12 y A11 (equivalente funcional a 4 AND de 4 entradas). Cualquiera de las dos vale.
  4. Reparto de nibble en los chips en paralelo (parte b–d). Con 2 chips 2K×4 por banco, la guía asigna el chip «alto» a D7–D4 y el «bajo» a D3–D0; el examen no fija cuál de los dos va a cada nibble — es decisión propia, solo hay que ser coherente en el diagrama.
  5. Alcance del VHDL (parte e). El módulo debe cubrir el mapa nuevo completo: CS de M1, CS de M2 y las 4 CS de los bancos ROM (salidas todas a nivel ALTO). Los huecos A000H–BFFFH y C000H–DFFFH no generan ninguna señal: ahí ninguna CS debe activarse.

No son supuestos —los fija el examen y hay que respetarlos sí o sí: CPU con bus de datos de 8 bits y de direcciones de 16 bits; el subsistema de la figura tal como está dibujado; añadir 8 KB de ROM que terminen en 0xFFFF con chips 2K×4 y CS activa a nivel alto; baremo 0,5 + 0,75 + 0,25 + 1,0 + 0,5 = 3,0.


Problema 1 — Proceso de mezcla: ASM + VHDL (3,5 puntos)

Figura del enunciado (imagen nativa del PDF): el proceso de mezcla — agua por la válvula V2, producto por la válvula V1 sobre el depósito intermedio con la báscula «Peso (P)», compuerta con motor C al depósito de mezcla y agitador M.
Figura del enunciado (imagen nativa del PDF): el proceso de mezcla — agua por la válvula V2, producto por la válvula V1 sobre el depósito intermedio con la báscula «Peso (P)», compuerta con motor C al depósito de mezcla y agitador M.

Enunciado (literal de la hoja del examen). «1. (3,5 puntos). Se pretende realizar una mezcla de un determinado producto y agua. El proceso de mezcla se inicia al pulsar A (A es un PULSADOR) y se realiza de la siguiente forma: - Se permite salir agua a través de la válvula V2 durante un tiempo T1 = 10 s. - A continuación, el producto es vertido sobre un depósito intermedio mediante una válvula V1 hasta que alcanza un peso P. - Luego, el producto pesado se echa en el depósito de mezcla a través de una compuerta activada por el motor C. El tiempo de descarga es T2 = 5 s. - Finalmente, en el depósito de mezcla se activa un motor M que debe mover la mezcla durante 10 segundos. Se dispone de un reloj de 10 Mhz. [...] Realizar el sistema de control del proceso. Se pide: a) Diagrama ASM de funcionamiento del sistema de control (2 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: A es un PULSADOR (lo dice expreso y es el arranque del proceso); el agua sale por la válvula V2 durante T1 = 10 s justos; el producto se vierte por la válvula V1 sobre un depósito intermedio «hasta que alcanza un peso P»; la compuerta la activa el motor C y la descarga dura T2 = 5 s; el motor M agita 10 s; reloj de 10 MHz; baremo a) 2 p + b) 1,5 p = 3,5 p.

La figura del examen (nativa en figuras/sept22/recortes/figura-p1-mezcla-nativa.jpg, auditada con visión) fija la topología: tolva «Agua» con válvula V2 que vierte al depósito de mezcla; tolva «Producto» con válvula V1 que vierte sobre la bandeja basculante; la báscula rotulada «Peso (P)» que la sustenta; la bandeja/compuerta con pivote rotulado C que vuelca al «Depósito de mezcla»; y el agitador interior con el motor M debajo. En la figura no hay sensor de nivel de agua ni sensor de fin de agitación: el único sensor es la báscula P (el «depósito intermedio» no lleva rótulo de texto: es la bandeja apoyada en la báscula).

Anotación sobre P: «hasta que alcanza un peso P» es la lectura del sensor de pesaje —la báscula «Peso (P)» de la figura—, no un pulsador. El único pulsador es A, y el enunciado lo aclara entre paréntesis. Tratar P como un pulsador, o A como un nivel, es la trampa del ejercicio.

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

  1. Un único temporizador para las tres cuentas: pre-escala MOD-10⁶ compartida + un contador de ticks con cuenta programada (compara 99 en AGUA/MEZCLA y 49 en DESCARGA). Justificación: en una ASM solo hay un estado activo, luego nunca hay dos cuentas simultáneas — duplicar la pre-escala es desperdiciar 20 bits tres veces — y las tres duraciones comparten el mismo tick de 0,1 s; lo único que cambia es el objetivo del contador de ticks, que depende del estado (Tema 2 p. 58: asociación síncrona por habilitación). Alternativa equivalente y válida, documentada y no desarrollada: un único contador de 27 bits con cuenta programada (2²⁷ = 134.217.728 ≥ 10⁸).
  2. A es una pulsación humana de duración indeterminada: la transición se etiqueta «frente de subida de A» (sincronizador de 2 FF + retardo con el que se compara). Una pulsación = un arranque, incluso si el botón queda mantenido. Es la misma doctrina del antirrebote del Tema 3 (p. 26) y del pulsador P de la grúa de junio-2022.
  3. P se lee por nivel (la báscula asienta a nivel estable cuando el peso llega) y también pasa por 2 FF por ser entrada asíncrona al sistema síncrono (Tema 3 p. 25: registrar los puertos de entrada).
  4. El nivel de fin de cuenta se limpia al cambiar de estado: los estados temporizados son vecinos en el grafo (DESCARGA → MEZCLA) y, si el «fin» del contador de 5 s sobreviviera al cambio, MEZCLA terminaría 1 ciclo después de empezar. Es el bug fino del ejercicio (verificado: ver «Errores típicos»).
  5. reset síncrono activo a nivel alto, en los puertos y OBLIGATORIO (Tema 3 p. 30: a la tarjeta identificativa del ASM «hay que añadirle las señales de reloj y reset»; garantiza arranque en ESPERA y deja contador y salidas en reposo).
  6. Nombre de la entidad VHDL: ControlMezcla. No puede ser Mezcla: los nombres VHDL son insensibles a mayúsculas y el literal colisionaría con el estado MEZCLA del ASM (GHDL lo analiza con warning de ocultación, pero deja de ser referenciable limpio en un testbench). Los nombres de los estados sí son exactamente los rótulos del ASM.

Planteamiento. Cuatro fases encadenadas y un reposo: una fase, un estado — ESPERA, AGUA, PESA, DESCARGA, MEZCLA (5 bloques ASM). Las salidas son Moore dentro de la caja de estado: V2, C y M duran lo que dura su cuenta (10 s, 5 s y 10 s a 10 MHz, con cascada MOD-10⁶ × MOD-100/50), y V1 dura lo que tarde la báscula en alcanzar el peso P (el tiempo de llenado NO lo fija el enunciado: PESA sale por sensor, nunca por cuenta). ESPERA es el único estado que mira el pulsador, y solo por frente de subida: A mantenido no re-dispara el ciclo.

Cálculo de las esperas: 10 s y 5 s con reloj de 10 MHz (imprescindible, va en el apartado a)

10 s x 10.000.000 pulsos/s = 100.000.000 pulsos = 10^8   (T1 = agua, y agitacion final)
 5 s x 10.000.000 pulsos/s =  50.000.000 pulsos = 5x10^7 (T2 = descarga)

Se descomponen en dos contadores en cascada, compartiendo la pre-escala (solo puede haber una cuenta activa a la vez):

Etapa Módulo Cuenta con Resultado Bits necesarios
Pre-escala MOD-1.000.000 10 MHz 1 tick cada 0,1 s (10 Hz) 20 (2²⁰ = 1.048.576 ≥ 10⁶ > 2¹⁹ = 524.288)
Ticks T1 MOD-100 10 Hz 100 x 0,1 s = 10,00 s justos 7 (2⁷ = 128 ≥ 100 > 2⁶ = 64)
Ticks T2 MOD-50 10 Hz 50 x 0,1 s = 5,00 s justos 6 (2⁶ = 64 ≥ 50 > 2⁵ = 32)

Comprobación: 10⁶ × 100 = 10⁸ ✔ y 10⁶ × 50 = 5×10⁷ ✔. El contador de ticks cambia el objetivo según el estado: compara 99 (100 ticks) en AGUA y MEZCLA, y 49 (50 ticks) en DESCARGA. Los contadores solo cuentan mientras la ASM permanece en el estado temporizado (habilitación por el estado) y se limpian al salir de él; el nivel de fin de cuenta (T1FIN/T2FIN) provoca la salida del estado.

Alternativa equivalente y válida: un único contador MOD-10⁸ de 27 bits con cuenta programada (2²⁷ = 134.217.728 ≥ 10⁸ > 2²⁶ = 67.108.864). La cascada 10⁶ × 100/50 es la que se usa en clase (asociación síncrona por habilitación).

📚 Teoría: Tema 2, pág. 56–58 del PDF «Tema 2 SD-II_20200317.pdf» — contador síncrono con habilitación y borrado; asociación de contadores para obtener mayor módulo y, en particular, la asociación síncrona que «emplea las entradas y salidas de habilitación de cuenta»: aquí el contador de ticks avanza solo cuando la pre-escala completa su ciclo, con ambos flancos de reloj aplicados simultáneamente.

a) Diagrama ASM — 5 estados (2 puntos)

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

# Bloque ASM (estado) Salida Decisiones → siguiente estado
1 ESPERA (reposo) — frente de subida de A → AGUA (único estado que mira el pulsador)
2 AGUA [V2=1] V2=1 T1FIN=1 (100 ticks = 10 s) → PESA
3 PESA [V1=1] V1=1 P=0: quedarse (la báscula aún no llega) · P=1 → DESCARGA
4 DESCARGA [C=1] C=1 T2FIN=1 (50 ticks = 5 s) → MEZCLA
5 MEZCLA [M=1] M=1 fin de agitación (100 ticks = 10 s) → ESPERA
stateDiagram-v2 [*] --> ESPERA : reset ESPERA --> AGUA : frente de subida de A (pulsador) AGUA --> PESA : T1FIN=1 (cuenta de 10 s) PESA --> DESCARGA : P=1 (la bascula alcanza el peso) DESCARGA --> MEZCLA : T2FIN=1 (cuenta de 5 s) MEZCLA --> ESPERA : fin de cuenta de 10 s de agitacion

Claves del planteamiento (lo que puntúa):

Ejemplo de recorrido: reposo →(pulsa A 3 ciclos) AGUA[V2=1, 10 s] → PESA[V1=1; la báscula tarda lo que tarde: 4 s de llenado p. ej.] →(P=1) DESCARGA[C=1, 5 s] → MEZCLA[M=1, 10 s] → ESPERA; si el botón siguiera mantenido al volver, nada: hay que soltar y volver a pulsar para el siguiente lote.

📚 Teoría: Tema 3, págs. 15–19 del PDF «Tema 3 SD-II_20200413.pdf» — cajas de estado (Moore, con las salidas de control dentro), de selección y de condición; el bloque ASM lo forman todos los elementos entre dos cajas de estado, incluida solo la primera. 📚 Teoría: Tema 3, pág. 25 del PDF «Tema 3 SD-II_20200413.pdf» — errores comunes: los puertos de entrada se registran en señales internas (aquí A y P pasan por 2 FF antes de tocar la lógica). 📚 Teoría: Tema 3, pág. 26 del PDF «Tema 3 SD-II_20200413.pdf» — antirrebote: activar la salida una sola vez por pulsación.

b) Módulo VHDL del ASM (1,5 puntos)

📚 Teoría: Tema 3, págs. 23–24 del PDF «Tema 3 SD-II_20200413.pdf» — diagrama ASM y módulo VHDL equivalente, el uno junto al otro. 📚 Teoría: Tema 3, págs. 30–32 del PDF «Tema 3 SD-II_20200413.pdf» — traducción de ASM a VHDL: «no es necesario llegar a una descripción como una estructura de componentes»; se describe el comportamiento «como si fuera un diagrama de estados» añadiendo reloj y reset a la tarjeta identificativa. 📚 Teoría: Tema 3, págs. 33–34 del PDF «Tema 3 SD-II_20200413.pdf» — simulación en VHDL usando parametrización: «el valor de la cuenta máxima del contador se ha reducido» (aquí los generic).

Analizado con GHDL 4.1.0 (--std=08 -fsynopsys, el estilo de clase usa STD_LOGIC_UNSIGNED) y verificado con un testbench a la manera de clase (proceso de estímulos con wait until clk='1', pulsos contados de flanco a flanco) que comprueba: reset con todo en reposo; ciclo completo con duraciones exactas contadas en flancos — V2 alto (PRE+1)·100 flancos, C alto (PRE+1)·50, M alto (PRE+1)·100, sin solapes entre actuadores (monitor); PESA leída por nivel (sale 4 flancos después de alcanzar el peso, incluidos los 2 FF) y bloqueada 2000 flancos con P=0 sin avanzar nada (no hay timeout inventado); A mantenido durante todo el ciclo NO re-dispara (200 flancos en ESPERA con el botón pulsado y V2=0; soltar y volver a pulsar sí arranca el segundo ciclo); y reset a mitad de AGUA que lo limpia todo y deja la segunda cuenta justa (mismos 1000 flancos exactos: sin restos de contador). Escala de simulación PRE=9: TEST PASSED (220.751 ns); segunda escala PRE=49: TEST PASSED (900.751 ns) — asserts calculados sobre las constantes, linealidad exacta. En el examen se escriben las constantes reales (G_PRE_MAX = 999_999, 99 y 49): extrapolado, V2 y M = 100.000.001 ciclos y C = 50.000.001 ciclos — las cuentas exactas de 10⁸ y 5×10⁷ más la latencia de entrada/salida del registro de estado. El no-re-disparo con A mantenido del testbench es además el detector vivo de la mutación «A leído por nivel»: con esa mutación ese assert cae. (El espejo del ASM y las tres mutaciones del TB anterior ya no se re-ejecutan; registrado en NOTAS.)

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;      -- sumas/comparaciones sobre vectores (estilo de clase)

entity ControlMezcla is
    generic (
        G_PRE_MAX  : integer := 999_999;  -- pre-escala: cuenta 0..999.999 (MOD-1e6, 20 bits)
        G_T1_TICKS : integer := 100;      -- 100 ticks de 0,1 s = T1 = 10 s (MOD-100, 7 bits)
        G_T2_TICKS : integer := 50       -- 50 ticks de 0,1 s = T2 = 5 s (MOD-50, 6 bits)
    );
    port (
        clk, reset   : in  std_logic;     -- reloj y reset van en la tarjeta identificativa
        A            : in  std_logic;     -- PULSADOR de arranque (pulso de duracion indeterminada)
        P            : in  std_logic;     -- sensor de PESO del deposito intermedio (nivel)
        V2, V1, C, M : out std_logic      -- valv. agua / valv. producto / motor compuerta / motor agitador
    );
end entity ControlMezcla;

architecture ASM of ControlMezcla is
    -- nombres de estado = nombres de los bloques del diagrama ASM
    type mis_estados is (ESPERA, AGUA, PESA, DESCARGA, MEZCLA);
    signal estado : mis_estados;

    -- temporizador: pre-escala MOD-1e6 compartida + contador de ticks con cuenta
    -- programada (compara 99 en AGUA/MEZCLA y 49 en DESCARGA)
    signal pre   : std_logic_vector(19 downto 0);  -- 10 MHz -> un tick cada 0,1 s
    signal ticks : std_logic_vector(6  downto 0);  -- llega a 99

    -- sincronizadores de 2 FF (entradas asyncronas, Tema 3 p.25) + retardo del flanco
    signal a1, a2, a3, p1, p2 : std_logic;
begin
    process
        begin
            wait until clk = '1';
            a1 <= A;  a2 <= a1;  a3 <= a2;    -- A y P pasan por 2 FF antes de la logica
            p1 <= P;  p2 <= p1;
            if (reset = '1') then             -- reset SINCRONO: estado, cuentas y salidas a reposo
                estado <= ESPERA;
                pre    <= (others => '0');
                ticks  <= (others => '0');
                a1 <= '0'; a2 <= '0'; a3 <= '0';  p1 <= '0'; p2 <= '0';
                V2 <= '0'; V1 <= '0'; C <= '0'; M <= '0';
            else
                case estado is
                    when ESPERA =>            -- reposo: unico estado que mira el pulsador
                        V2 <= '0'; V1 <= '0'; C <= '0'; M <= '0';
                        pre   <= (others => '0');
                        ticks <= (others => '0');
                        if (a2 = '1' and a3 = '0') then  -- frente de subida: un pulso, una actuacion
                            estado <= AGUA;
                        end if;

                    when AGUA =>              -- agua por V2: 100 ticks de 0,1 s = 10 s
                        V2 <= '1'; V1 <= '0'; C <= '0'; M <= '0';
                        if pre = G_PRE_MAX then
                            pre <= (others => '0');
                            if ticks = G_T1_TICKS - 1 then
                                ticks <= (others => '0');  -- salida limpia: sin cuenta fantasma
                                estado <= PESA;
                            else
                                ticks <= ticks + 1;
                            end if;
                        else
                            pre <= pre + 1;
                        end if;

                    when PESA =>              -- producto por V1 hasta el peso P (NIVEL de la bascula)
                        V1 <= '1'; V2 <= '0'; C <= '0'; M <= '0';
                        pre   <= (others => '0');   -- PESA no temporiza: contadores a 0
                        ticks <= (others => '0');
                        if (p2 = '1') then estado <= DESCARGA; end if;

                    when DESCARGA =>          -- compuerta con motor C: 50 ticks = 5 s
                        C <= '1'; V2 <= '0'; V1 <= '0'; M <= '0';
                        if pre = G_PRE_MAX then
                            pre <= (others => '0');
                            if ticks = G_T2_TICKS - 1 then
                                ticks <= (others => '0');  -- limpia: MEZCLA empieza de cero
                                estado <= MEZCLA;
                            else
                                ticks <= ticks + 1;
                            end if;
                        else
                            pre <= pre + 1;
                        end if;

                    when MEZCLA =>            -- agitador M: 100 ticks = 10 s (misma pre-escala)
                        M <= '1'; V2 <= '0'; V1 <= '0'; C <= '0';
                        if pre = G_PRE_MAX then
                            pre <= (others => '0');
                            if ticks = G_T1_TICKS - 1 then
                                ticks <= (others => '0');
                                estado <= ESPERA;          -- lote hecho: a esperar nueva pulsacion
                            else
                                ticks <= ticks + 1;
                            end if;
                        else
                            pre <= pre + 1;
                        end if;

                    when others => estado <= ESPERA;
                end case;
            end if;
        end process;
end architecture ASM;

Notas para el examen: escribe las constantes directamente en el código (no hace falta el generic): compara pre = 999_999, ticks = 99 y ticks = 49; el generic de este listado es solo para poder simular (Tema 3 p. 33–34: «el valor de la cuenta máxima se ha reducido»). Estructura de clase (Tema 3 págs. 30–32): un solo proceso con wait until clk='1', reset síncrono que limpia estado, cuentas y salidas, estados con los rótulos del ASM, las salidas escritas dentro de cada rama when (la memoria implícita del proceso las conserva: cada rama pone a '0' las ajenas), sincronizador de 2 FF para A y P, y when others => de seguridad. No llames Mezcla a la entidad: colisiona (insensible a mayúsculas) con el estado MEZCLA del ASM; ControlMezcla u otro nombre compuesto vale. Los nombres de estado, en cambio, son exactamente los rótulos del diagrama.

Errores típicos — P1

Baremo real del problema

a) diagrama ASM 2 p + b) módulo VHDL 1,5 p = 3,5 p. Cuadra con el enunciado: sin erratas.

Esquema-resumen de la metodología

  1. Seca el enunciado en dos columnas — fija: pulsador A (así, entre paréntesis), T1 = 10 s, V1 hasta peso P (sensor), T2 = 5 s, agitación 10 s, reloj 10 MHz, baremo 2+1,5. No fija: tiempo de llenado (prohíbe temporizar PESA) ni magnitudes de sensores (la figura prohíbe inventar nivel de agua).
  2. Clasifica cada entrada por su naturaleza — A = pulsación humana → frente de subida; P = nivel de báscula → nivel sincronizado. Todo lo demás son salidas actuadas por estado.
  3. Calcula las cuentas antes de dibujar — 10⁸ y 5×10⁷ pulsos; cascada MOD-10⁶ × MOD-100/50 con bits justificados; apunta la alternativa del contador único de 27 bits en una línea.
  4. Un estado por fase con las salidas Moore dentro — ESPERA/AGUA/PESA/DESCARGA/MEZCLA; PESA sale por sensor y los otros tres temporizados salen por fin de cuenta compartido con cuenta programada.
  5. Traduce a VHDL con la estructura de clase — UN proceso con wait until clk='1', reset síncrono que limpia estado, cuentas y salidas; estados con los rótulos del ASM; salidas dentro de cada rama when (poniendo a '0' las ajenas); contador vector con cuenta programada y limpieza en la salida del estado; 2 FF en A y P; when others.
  6. Comprueba con los casos borde — botón mantenido (no re-dispara), báscula sin peso (no avanza), ratios medidos exactos y lineales con la pre-escala: ahí se cazan el re-disparo, el timeout inventado y el fin de cuenta fantasma, que no se ven en un ciclo feliz.

Idea transversal: el mismo proceso tiene dos vidas en este examen — aquí es ASM + contadores dentro de la lógica; en el Problema 2 son los contadores externos C10s/C5s y el programa picoBlaze que los arma fase a fase. La pre-escala compartida + ticks con cuenta programada es exactamente el «reusar C10s para la agitación» del P2 (con su reset previo): cambia la tecnología, la secuencia y los tiempos son los mismos — el ASM de este problema es el plano del programa de aquel.


Problema 2 — El proceso de mezcla con microcontrolador picoBlaze (3,5 puntos)

Planteamiento. Es el mismo proceso del Problema 1 (agua V2 durante 10 s, producto V1 hasta el peso P, compuerta C durante 5 s y motor M durante 10 s), pero gobernado por un microcontrolador PicoBlaze (firmcore KCPSM3) en vez de una máquina de estados ASM/VHDL. El reloj pasa a ser de 50 MHz y los tiempos ya no los genera el micro contando ciclos: los generan dos contadores hardware externos —C10s y C5s—, con entradas CLK, Reset e INICIO_CUENTA y salidas Fin_de_cuenta_10s y Fin_de_cuenta_5s. El programa es una secuencia recta de cuatro fases con sondeo de estado: cada fase enciende su actuador, dispara su contador con INICIO_CUENTA por escritura y espera la bandera Fin_de_cuenta por lectura.

Datos que fija el enunciado y decisiones de diseño

Fija el enunciado: reloj de 50 MHz; los contadores C10s y C5s con CLK activo a nivel alto, Reset activo a nivel alto que pone a 0 el interior del contador, INICIO_CUENTA que hace contar al aplicar un 1, y Fin_de_cuenta_10s / Fin_de_cuenta_5s puestos a 1 al llegar a la cuenta de 10 s y de 5 s; el bloque del micro 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]; y la tabla de instrucciones KCPSM3 impresa en el propio examen, que es la que manda (nada de mnemónicos de otras familias). Baremo: a) 1 p + b) 2,5 p = 3,5 p.

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

  1. Anchura del bus de programa. El bloque impreso acaba en ADDRESS[9:0]: 2^10 = 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, fuera del firmcore; el tamaño exacto lo elige el diseñador).
  2. Cuentas de los contadores. El enunciado no dice cuántos pulsos hay que contar: a 50 MHz, 10 s son 5·10^8 pulsos y 5 s, 2,5·10^8. Descompongo con un preescalar fijo /1000 común (reloj de cuenta a 50 kHz) y referencias 500.000 (10 s; 19 bits: 2^19 = 524.288 ≥ 500.000) y 250.000 (5 s; 18 bits: 2^18 = 262.144 ≥ 250.000). Cualquier descomposición equivalente vale, pero hay que declararla.
  3. Puertos y mapa de bits. Asigno puerto de entrada H"00" (bit0 = A, bit1 = P, bit2 = Fin_de_cuenta_10s, bit3 = Fin_de_cuenta_5s) y puerto de salida H"00" (bit0 = V2, bit1 = V1, bit2 = C, bit3 = M, bit4 = INICIO_CUENTA_10s, bit5 = INICIO_CUENTA_5s, bit6 = Reset C10s, bit7 = Reset C5s). Entrada y salida pueden compartir número: se distinguen por la strobe del ciclo (READ_STROBE / WRITE_STROBE).
  4. Sondeo frente a interrupción. La espera de Fin_de_cuenta se hace por lectura (IN + TEST + JUMP Z), sin usar INTERRUPT ni INTERRUPT_ACK (el vector de interrupción en 3FFH no hace falta). Es decisión propia: el baremo no la exige y el sondeo es el camino corto y verificable.
  5. Reloj de cuenta de los contadores. El CLK de C10s y C5s es el tren de pulsos ya dividido (el enunciado dice «activo a nivel alto»: el contador toma pulsos mientras INICIO_CUENTA vale 1). El preescalar recibe el mismo CLK de 50 MHz que el núcleo.
  6. Re-Reset antes de cada arranque. C10s se usa dos veces (fases 1 y 4): cada arranque va precedido de su pulso Reset por escritura. Sin él, Fin_de_cuenta_10s quedaría en 1 de inicio y la fase 4 entera se saltaría.

Cálculos previos: los contadores a 50 MHz

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

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, uso de los contadores 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 4 del recuadro). El CLK de 50 MHz va al núcleo y, por la misma línea, al preescalar común de los contadores.
  2. Memoria de programa: ROM externa 1024 × 18. ADDRESS[9:0] (10 bits) sale al bus de direcciones de la ROM —block RAM de la FPGA, no está dentro del firmcore— y INSTRUCTION[17:0] (18 bits) vuelve de ella. El programa del apartado b (38 instrucciones) cabe con enorme holgura.
  3. Entradas con lectura aislada por strobe. Pulsador A (bit0), peso P (bit1), Fin_de_cuenta_10s (bit2) y Fin_de_cuenta_5s (bit3) se seleccionan comparando PORT_ID = H"00" con READ_STROBE: cada fuente entra en el bus IN_PORT[7:0] a través de una puerta tri-state habilitada por la decodificación (en el dibujo se resume como un MUX 4:1: funcionalmente es lo mismo).
  4. Salidas con latch por WRITE_STROBE. OUT_PORT[7:0] entra en un latch de 8 bits cuya escritura se habilita con la AND de PORT_ID = H"00" y WRITE_STROBE. Los bits 0–3 van a V2, V1, C y M: el latch mantiene el valor mientras el programa no lo cambie (V2 se queda a 1 durante todo el conteo de C10s); los bits 4–7 son las señales de control de los contadores.
  5. Contadores C10s y C5s como bloques externos. Reciben del preescalar común /1000 su CLK de cuenta (50 kHz) y del latch INICIO_CUENTA_10s, INICIO_CUENTA_5s, Reset C10s y Reset C5s. Sus salidas Fin_de_cuenta_10s y Fin_de_cuenta_5s vuelven al puerto de entrada del micro (bits 2 y 3 del puerto H"00"). Cada contador lleva dentro su comparador de referencia (500.000 y 250.000) que genera la bandera de fin.
Diagrama hardware del control del proceso de mezcla con PicoBlaze KCPSM3 (reloj 50 MHz) clk (reloj 50 MHz) 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 uso ROM de programa 1024 × 18 block RAM de la FPGA (NO dentro del núcleo) 000H-3FFH: 1024 instrucciones de 18 bits ADDRESS[9:0] = 2^10 = 1024 direcciones el tamano de la ROM es decision de la guia: el examen no lo fija aqui no hace falta vector de interrup clk reset CLK 50 MHz (compartido) ADDRESS INSTRUCTION Lógica de E/S en la FPGA (fuera del núcleo) los puertos se seleccion comparando PORT_ID con la strobe Pulsador A (bit0) Peso P (bit1) Fin de cuenta de los contadores (bits 2-3) = H"00" = H"00" = H"00" MUX 4:1 PORT_ID+rd IN_PORT[7:0] wr OUT_PORT[7:0] = H"00" (port_id) AND Latch 8 b salida habilitada bit0 → V2 (agua, 10 s) bit1 → V1 (producto, peso P) bit2 → C (compuerta, 5 s) bit3 → M (motor, 10 s) preescalar fijo /1000 50 MHz → 50 kHz común a C10s y C5s 50 kHz C10s · 500.000 pulsos = 10 s 19 bits: 524.288 ≥ 500.000 Fin_de_cuenta_10s al llegar a la cuenta de referencia C5s · 250.000 pulsos = 5 s 18 bits: 262.144 ≥ 250.000 Fin_de_cuenta_5s al llegar a la cuenta de referencia Fin_de_cuenta_10s Fin_de_cuenta_5s rojo discontinuo = PORT_ID y strobes · negro = buses de datos bit4-5: INICIO_CUENTA_10s y _5s · bit6-7: Reset C10s y Reset C5s sensores y Fin de cuenta entran por el puerto de entrada H"00" sondeado con IN Contadores (bloques externos): cuentan SOLO con INICIO_CUENTA=1; Reset nivel alto los pone a 0; Fin_de_cuenta_x=1 al llegar a la cuenta de referencia. Preescalar común /1000 (decisión): 10 s a 50 MHz = 5·10^8 pulsos → 500.000 a 50 kHz; 5 s → 250.000 pulsos. ROM externa 1024×18: ADDRESS[9:0] del bloque impreso da exactamente 2^10 posiciones. El contador C10s se usa dos veces (fases V2 y M).

Figura: diagrama hardware del Problema 2: núcleo KCPSM3 con la ROM de programa externa 1024×18, la lógica de puertos H"00" (mux de lectura, comparador+AND+latch de escritura) y los contadores externos C10s y C5s con preescalar común, que el micro arranca con INICIO_CUENTA y sondea por Fin_de_cuenta.

📚 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–34 del PDF «Tema 4 SD-II_20220512.pdf» — puertos de E/S: PORT_ID, strobes de lectura/escritura y conexión de entradas y salidas. 📚 Teoría: Tema 4, pág. 45 y 49 del PDF «Tema 4 SD-II_20220512.pdf» — almacenamiento del programa: bloque RAM 1Kx18 externo y conexión de la ROM del programa.

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

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

El programa (38 instrucciones; verificado con la trazada documentada en guias/NOTAS-elaboracion-septiembre-2022.md):

;=====================================================================
; Control del proceso de mezcla (Sept-2022) con PicoBlaze KCPSM3
; Reloj de 50 MHz compartido; los tiempos los dan los contadores
; hardware C10s y C5s. Solo mnemónicos de la tabla impresa en el
; examen: aquí se usan LOAD, IN, OUT, TEST y JUMP condicionado.
;
; Puerto de entrada H"00": bit0=A (pulsador)      bit1=P (peso)
;                         bit2=Fin_de_cuenta_10s  bit3=Fin_de_cuenta_5s
; Puerto de salida  H"00": bit0=V2  bit1=V1  bit2=C  bit3=M
;                   bit4=INICIO_CUENTA_10s  bit5=INICIO_CUENTA_5s
;                   bit6=Reset C10s         bit7=Reset C5s
;=====================================================================
P_ENT   EQU H"00"          ; puerto de lectura  (decisión propia)
P_SAL   EQU H"00"          ; puerto de escritura (decisión propia)

        ORG H"000"
; ---------------------------------------------------------------------
; Arranque: dejar los dos contadores a 0 y las salidas del proceso
; apagadas antes de esperar la orden del pulsador A.
; ---------------------------------------------------------------------
INICIO: LOAD s7, H"00"     ; s7 = máscara "todas las salidas apagadas"
        LOAD s8, H"C0"     ; bit6+bit7 = Reset de C10s y C5s a nivel 1
        OUT s8, P_SAL      ; escribe: deja los dos contadores en 0
        OUT s7, P_SAL      ; retira los Reset y deja V2,V1,C,M en 0
; ---------------------------------------------------------------------
; Espera de orden: sondeamos A (bit0) hasta que el pulsador esté en 1.
; ---------------------------------------------------------------------
ESPERA: IN s1, P_ENT       ; leemos el estado del proceso
        TEST s1, H"01"     ; probamos bit0 (A): deja Z=1 si A vale 0
        JUMP Z, ESPERA     ; mientras A no sea 1, seguimos esperando
; ---------------------------------------------------------------------
; Fase 1: agua V2 durante T1 = 10 s. Preparamos C10s: Reset a 0 y
; luego arranque con INICIO_CUENTA en la misma escritura de la fase.
; ---------------------------------------------------------------------
        LOAD s8, H"40"     ; bit6=1: Reset de C10s (poner su cuenta a 0)
        OUT s8, P_SAL      ; salidas del proceso todavía apagadas
        LOAD s2, H"11"     ; bit0=V2 activa + bit4=INICIO_CUENTA_10s=1
        OUT s2, P_SAL      ; V2 abre el agua y C10s empieza a contar
POLL10: IN s1, P_ENT       ; sondeamos Fin_de_cuenta_10s
        TEST s1, H"04"     ; probamos bit2: Z=1 si aún no ha acabado
        JUMP Z, POLL10     ; mientras C10s no llegue a su cuenta, sigo
; ---------------------------------------------------------------------
; Fase 2: producto V1 hasta que el peso P esté en 1 (sin temporizador:
; el micro cierra la fase cuando el sensor de peso lo indica).
; ---------------------------------------------------------------------
        OUT s7, P_SAL      ; apaga V2 (fin del llenado de agua)
        LOAD s2, H"02"     ; bit1=V1; el resto de bits queda a 0
        OUT s2, P_SAL      ; V1 vierte el producto sobre el depósito
POLLP:  IN s1, P_ENT       ; sondeamos el peso
        TEST s1, H"02"     ; probamos bit1 (P): Z=1 si aún no pesa lo justo
        JUMP Z, POLLP      ; espero a que el peso alcance P
; ---------------------------------------------------------------------
; Fase 3: compuerta C durante T2 = 5 s, con el contador C5s.
; ---------------------------------------------------------------------
        OUT s7, P_SAL      ; apaga V1 (producto ya pesado)
        LOAD s8, H"80"     ; bit7=1: Reset de C5s (poner su cuenta a 0)
        OUT s8, P_SAL      ; C5s queda preparado
        LOAD s2, H"24"     ; bit2=C activa + bit5=INICIO_CUENTA_5s=1
        OUT s2, P_SAL      ; C abre la compuerta y C5s empieza a contar
POLL5:  IN s1, P_ENT       ; sondeamos Fin_de_cuenta_5s
        TEST s1, H"08"     ; probamos bit3: Z=1 si aún no han pasado 5 s
        JUMP Z, POLL5      ; espero el fin de la descarga
; ---------------------------------------------------------------------
; Fase 4: motor M de agitación durante 10 s. Reutilizo C10s: OBLIGO a
; Resetearlo ANTES de volver a darle INICIO_CUENTA (si no, Fin_de_
; cuenta_10s estaría en 1 de inicio y la fase entera se saltaría).
; ---------------------------------------------------------------------
        OUT s7, P_SAL      ; apaga C (descarga terminada)
        LOAD s8, H"40"     ; bit6=1: Reset de C10s otra vez
        OUT s8, P_SAL      ; C10s vuelve a quedar en 0
        LOAD s2, H"18"     ; bit3=M activa + bit4=INICIO_CUENTA_10s=1
        OUT s2, P_SAL      ; M arranca y C10s cuenta sus 10 s
POLL10B: IN s1, P_ENT       ; sondeamos Fin_de_cuenta_10s (segundo uso)
        TEST s1, H"04"     ; probamos bit2 de nuevo
        JUMP Z, POLL10B    ; espero los 10 s de agitación
        OUT s7, P_SAL      ; apaga M: proceso completo, todo en reposo
        JUMP ESPERA        ; y vuelta a esperar el próximo pulsador A

Justificaciones que el examinador pide explicar:

Trazada de verificación (emulador mínimo del subconjunto KCPSM3 + entorno con los contadores y el preescalar, en la nota de elaboración). Las transiciones del latch reproducen el orden exacto del enunciado (clk del modelo = pulsos de cuenta a 50 kHz):

clk      3: todo 0          → 11000000  (Reset C10s+C5s del arranque)
clk      4: todo 0          (salidas apagadas; se espera A)
clk      9:                 → 01000000  (Reset C10s antes de la fase 1)
clk     11:                 → 00010001  (V2=1 + INICIO_CUENTA_10s=1)
clk 500016:                 → 00000000  (Fin_de_cuenta_10s: 500.000 pulsos = 10 s)
clk 500018:                 → 00000010  (V1; cierra en clk 502023 al llegar P)
clk 502025:                 → 10000000  (Reset C5s antes de la fase 3)
clk 502027:                 → 00100100  (C=1 + INICIO_CUENTA_5s=1)
clk 752030:                 → 00000000  (Fin_de_cuenta_5s: 250.000 pulsos = 5 s)
clk 752032:                 → 01000000  (Reset C10s: segundo uso del contador)
clk 752034:                 → 00011000  (M=1 + INICIO_CUENTA_10s=1)
clk1252039:                 → 00000000  (Fin_de_cuenta_10s: otros 10 s; y loop)

Asserts de la trazada: orden de fases correcto; duraciones exactas de cuenta (500.000 / 250.000 / 500.000 pulsos a 50 kHz); C10s vuelve a llegar a su referencia tras ser re-Resetado entre usos; ningún contador rebasa su referencia; V2 permanece a 1 durante toda la fase 1; el ciclo se cierra y vuelve a ESPERA. 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.

Errores típicos — P2

Baremo real del problema

a) Diagrama hardware (conexiones, contadores, 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 la tabla KCPSM3: el diagrama se dibuja alrededor de esos pines y el ensamblador solo puede usar mnemónicos de la tabla.
  2. Convertir los tiempos del proceso a pulsos de reloj — 10 s y 5 s a 50 MHz dan cuentas enormes (5·10^8 y 2,5·10^8 pulsos): se descomponen con un preescalar común (/1000 → 50 kHz) y referencias que caben en 19 y 18 bits (500.000 y 250.000).
  3. Cada fase = actuador + contador + sondeo — por escritura se coloca el latch con la máscara completa (actuador + INICIO_CUENTA, con el Reset ya retirado) y por lectura se espera Fin_de_cuenta con IN + TEST + JUMP Z.
  4. Re-Reset antes de cada arranque de contador — sobre todo C10s, que se usa dos veces: el pulso Reset por escritura evita que la fase salte de golpe.
  5. Sondeo antes que interrupción — salvo que el enunciado pida INTERRUPT expresamente, el camino corto es la lectura del estado: menos hardware, menos rutinas, más fácil de verificar.
  6. Documentar puertos y bits — EQU de puertos y mapa de bits en comentario: el examinador sigue el programa bit a bit y ahí está el grueso de los 2,5 puntos del ensamblador.

Idea transversal: en un microcontrolador el software no temporiza: ordena y sondea a un hardware de tiempos (contadores con referencia fija y bandera de fin); la gracia del ejercicio es ver cómo las cuatro cajas del ASM del Problema 1 se convierten en cuatro bloques rectos de OUT … IN + TEST + JUMP, sin una sola instrucción perdida por el camino

Problema 3 — Mapa de memoria y ampliación de 8 KB de ROM (3,0 puntos)

Enunciado íntegro del Problema 3 (mapa para CPU de 8 bits datos y 16 bits direcciones): analizar el subsistema de la figura y determinar el mapa; si es posible, añadir 8 KB de ROM que terminen en 0xFFFF con chips 2Kx4 y CS activa a nivel alto. Baremo real 0,5+0,75+0,25+1,0+0,5 (3,0 puntos).
Enunciado íntegro del Problema 3 (mapa para CPU de 8 bits datos y 16 bits direcciones): analizar el subsistema de la figura y determinar el mapa; si es posible, añadir 8 KB de ROM que terminen en 0xFFFF con chips 2Kx4 y CS activa a nivel alto. Baremo real 0,5+0,75+0,25+1,0+0,5 (3,0 puntos).

Planteamiento. La CPU tiene bus de datos de 8 bits y bus de direcciones de 16 bits → 2¹⁶ = 65 536 posiciones, mapa 0000H–FFFFH, líneas A15–A0. El subsistema de la figura está construido sobre un decodificador 2–4 con A15 y A14 en el select: M1 (RAM, direcciones internas A14–A0) se habilita con Y0+Y1 — es decir, con NOT(A15) — y M2 (RAM, internas A12–A0) con Y2·NOT(A13). El mapa sale directo de las ecuaciones de CS. Para la ampliación, la ROM de 8 KB anclada al final del mapa termina en 0xE000H–0xFFFFH: la salida Y3 del decodificador está libre y A13 vale 1 en toda esa ventana, así que la habilitación común de la ROM es Y3·A13 y la decodificación interna de los bancos usa A12 y A11, que ningún módulo existente consume en esa zona → la ampliación es posible sin solapes. Los bancos de 2K×8 se montan con 2 chips 2K×4 en paralelo (expansión de bits 4→8) y hacen falta 4 bancos (expansión de palabras 8K/2K) → 8 chips 2K×4 en total.

Datos que fija el enunciado y decisiones de diseño. Fija el enunciado: los buses de 8 (datos) y 16 (direcciones) líneas; el subsistema de la figura (DEC 2–4 sobre A15, A14; OR sobre Y0,Y1 a la CS de M1; AND con A13 negada a la CS de M2; Y3 suelta; CS de los módulos activas ALTAS; R/W̄ global); la capacidad de los módulos, que sale de sus pines de dirección (M1 = A14–A0 → 32K×8; M2 = A12–A0 → 8K×8, supuesto 2); los 8 KB de ROM acabando en 0xFFFF (→ E000H–FFFFH, posición única posible); los chips 2K×4 con CS ALTA; y el baremo a) 0,5 · b) 0,75 · c) 0,25 · d) 1,0 · e) 0,5 (suma 3,0, cuadra con el enunciado). No lo fija el enunciado: la estructura del decodificador de la ampliación (supuesto 3: segundo DEC 2–4 con enable, o 4 AND de 4 entradas), el reparto del nibble alto/bajo entre los chips en paralelo (supuesto 4), el alcance exacto del módulo VHDL (supuesto 5: cubrir el mapa nuevo completo) y la lectura de la barra sobre A13, que no es supuesto: está dibujada en la figura y es dato del examen (supuesto 1 la documenta).

Datos de partida y cálculos de cabida

a) Mapa de memoria de la figura (0,5 puntos)

Figura incrustada original del examen (imagen nativa del PDF): DEC 2–4 con select pin 1 = A15 y pin 0 = A14; Y0 e Y1 pasan por una OR a la CS de M1 (RAM, direcciones A14–A0 → 32K×8); Y2 y A13 con barra entran en una AND que va a la CS de M2 (RAM, A12–A0 → 8K×8); Y3 queda suelta; R/W̄ global y datos D7–0 compartidos. CS sin burbuja = activas a nivel ALTO.
Figura incrustada original del examen (imagen nativa del PDF): DEC 2–4 con select pin 1 = A15 y pin 0 = A14; Y0 e Y1 pasan por una OR a la CS de M1 (RAM, direcciones A14–A0 → 32K×8); Y2 y A13 con barra entran en una AND que va a la CS de M2 (RAM, A12–A0 → 8K×8); Y3 queda suelta; R/W̄ global y datos D7–0 compartidos. CS sin burbuja = activas a nivel ALTO.

Las capacidades no están rotuladas: se deducen de las líneas de dirección de cada bloque (M1: A14–A0 → 32K×8; M2: A12–A0 → 8K×8, supuesto 2) y se contrastan con la señal CS que las activa:

Módulo Tamaño Selección CS (ecuación) Inicial hex Final hex Posiciones
M1 RAM 32K×8 Y0+Y1 = NOT(A15) 0000H 7FFFH 32 768
M2 RAM 8K×8 Y2·NOT(A13) 8000H 9FFFH 8 192
Libre — Y2·A13, no decodificado A000H BFFFH 8 192
Libre — Y3 ( salida suelta en la figura) C000H FFFFH 16 384

Mapa de la figura (lo que hay que copiar en el examen):

0000H ┌────────────────────────────────┐
      │ M1 RAM 32K×8  CS = Y0+Y1       │   CS ALTA (sin burbuja)
7FFFH ├────────────────────────────────┤
      │ M2 RAM  8K×8  CS = Y2·NOT(A13) │   CS ALTA
9FFFH ├────────────────────────────────┤
      │ Libre A000H–BFFFH (sin CS)     │   Y2 con A13=1: nada lo activa
BFFFH ├────────────────────────────────┤
      │ Libre C000H–FFFFH (sin CS)     │   Y3 suelta
FFFFH └────────────────────────────────┘

Por qué M1 ocupa la mitad baja entera: Y0 e Y1 son los dos casos de A15=0 (A14=0 y A14=1); la OR de ambas equivale a NOT(A15) y cubre 0000H–7FFFH, que son justo las 2¹⁵ posiciones de las internas A14–A0 del módulo — no queda aliasing. Por qué M2 no llega a A000H–BFFFH: la AND de su CS exige A13 negada (burbuja en la entrada del esquema), así que con A13=1 ninguna CS se activa y ese hueco queda libre.

(Figura del enunciado: la imagen nativa del subsistema va insertada aquí en la versión publicada mediante el JSON de figuras.)

📚 Tema 5, págs. 32–33 (concepto de mapa de memoria, numeración hexadecimal 0000H–FFFFH y ejemplo de diseño con RAM al principio y ROM al final); Tema 1, pág. 3 (definición de decodificador completo y sus entradas de HABILITACIÓN).

b) Tabla del nuevo mapa, en binario y hexadecimal (0,75 puntos)

Binario: las 16 líneas A15…A0 agrupadas de 4 en 4 (cada grupo = un dígito hex). Las ecuaciones de CS de los bancos salen del enable común EN = Y3·A13 más la combinación de A12 y A11:

Módulo Inicial (binario A15…A0) Final (binario A15…A0) Inicial hex Final hex Posiciones CS (ALTA)
M1 RAM 0000 0000 0000 0000 0111 1111 1111 1111 0000H 7FFFH 32 768 NOT(A15) (Y0+Y1)
M2 RAM 1000 0000 0000 0000 1001 1111 1111 1111 8000H 9FFFH 8 192 Y2·NOT(A13)
Libre 1010 0000 0000 0000 1011 1111 1111 1111 A000H BFFFH 8 192 ninguna
Libre 1100 0000 0000 0000 1101 1111 1111 1111 C000H DFFFH 8 192 ninguna
ROM banco 1 1110 0000 0000 0000 1110 0111 1111 1111 E000H E7FFH 2 048 Y3·A13·NOT(A12)·NOT(A11)
ROM banco 2 1110 1000 0000 0000 1110 1111 1111 1111 E800H EFFFH 2 048 Y3·A13·NOT(A12)·A11
ROM banco 3 1111 0000 0000 0000 1111 0111 1111 1111 F000H F7FFH 2 048 Y3·A13·A12·NOT(A11)
ROM banco 4 1111 1000 0000 0000 1111 1111 1111 1111 F800H FFFFH 2 048 Y3·A13·A12·A11

Nivel CI (qué selecciona cada integrado). Cada banco son 2 chips 2K×4 que comparten CS y las internas A10–A0 (2K = 2¹¹); uno conduce D7–D4 y su gemelo D3–D0 (supuesto 4). M1 usa A14–A0 internas, M2 usa A12–A0, la ROM usa A10–A0. Las líneas A15, A14, A13 y A12, A11 de la zona alta quedan en manos del decodificador.

CI / módulo Direcciones que ocupa Internas CS
M1 (RAM 32K×8) 0000H–7FFFH A14–A0 NOT(A15)
M2 (RAM 8K×8) 8000H–9FFFH A12–A0 Y2·NOT(A13)
ROM1a (D7–D4) + ROM1b (D3–D0) E000H–E7FFH A10–A0 banco 1
ROM2a (D7–D4) + ROM2b (D3–D0) E800H–EFFFH A10–A0 banco 2
ROM3a (D7–D4) + ROM3b (D3–D0) F000H–F7FFH A10–A0 banco 3
ROM4a (D7–D4) + ROM4b (D3–D0) F800H–FFFFH A10–A0 banco 4

Comprobación por conteo: 32 768 + 8 192 + 4·2 048 = 49 152 posiciones seleccionadas; huecos 8 192 + 8 192 = 16 384 sin seleccionar; total 65 536, solapes 0 (verificado dirección a dirección en el apartado e).

📚 Tema 5, págs. 34–35 (obtención de las condiciones de habilitación de cada integrado del ejemplo de mapa de memoria, exactamente el mismo método de fijar combinaciones de las líneas altas).

c) Mapa de la nueva configuración (0,25 puntos)

Es la tabla anterior dibujada como mapa vertical, en orden ascendente, con las direcciones inicial y final de cada módulo en hexadecimal (el examen lo pide a mano; la figura SVG validada va en la versión publicada):

0000H ┌────────────────────────────────┐
      │ M1 RAM 32K×8                   │  CS = NOT(A15)
7FFFH ├────────────────────────────────┤
      │ M2 RAM  8K×8                   │  CS = Y2·NOT(A13)
9FFFH ├────────────────────────────────┤
      │ Libre A000H–BFFFH (sin CS)     │
BFFFH ├────────────────────────────────┤
      │ Libre C000H–DFFFH (sin CS)     │
DFFFH ├────────────────────────────────┤
      │ ROM banco 1 · 2K×8 (2 chips)   │  E000H–E7FFH
E7FFH ├────────────────────────────────┤
      │ ROM banco 2 · 2K×8 (2 chips)   │  E800H–EFFFH
EFFFH ├────────────────────────────────┤
      │ ROM banco 3 · 2K×8 (2 chips)   │  F000H–F7FFH
F7FFH ├────────────────────────────────┤
      │ ROM banco 4 · 2K×8 (2 chips)   │  F800H–FFFFH
FFFFH └────────────────────────────────┘

Observa el detalle: la ROM acaba justo en FFFFH (anclaje del enunciado) y los dos huecos intermedios siguen sin decodificar — la ampliación no los toca.

El mapa dibujado de la nueva configuración (los rangos son los de la tabla del apartado b):

Mapa de memoria con la ampliacion: 65.536 posiciones 0000H-FFFFH (A15-A0 · D7-D0) inicio posiciones 0000H M1 RAM 32K×8 · CS ALTA (sin burbuja) 0000H-7FFFH · CS = NOT(A15) = Y0+Y1 (la OR de la figura) internas A14-A0 · D7-D0 · R/W‾ global 32.768 8000H M2 RAM 8K×8 · CS ALTA 8000H-9FFFH · CS = Y2 y NOT(A13) (la AND con burbuja) 8.192 A000H Libre A000H-BFFFH: ninguna CS activa (Y2 con A13=1) 8.192 C000H Libre C000H-DFFFH: ninguna CS activa (Y3 con A13=0) 8.192 E000H ROM nueva 8K · E000H-FFFFH · CS ALTA · EN comun = Y3 y A13 Banco 1 · E000H-E7FFH · CS = Y3·A13·NOT(A12)·NOT(A11) Banco 2 · E800H-EFFFH · CS = Y3·A13·NOT(A12)·A11 Banco 3 · F000H-F7FFH · CS = Y3·A13·A12·NOT(A11) Banco 4 · F800H-FFFFH · CS = Y3·A13·A12·A11 FFFFH 8.192 = 4×2.048 Alturas de caja NO a escala: lo que fija el mapa son los rangos de la izquierda y las posiciones de la derecha. Suma: 32.768 (M1) + 8.192 (M2) + 8.192 + 8.192 (dos huecos) + 8.192 (ROM) = 65.536 · solapes = 0 (verificado por barrido). Cada banco ROM = 2 chips 2K×4 en paralelo (D7-D4 y D3-D0) con CS comun e internas A10-A0; en total, 8 chips.

Figura: mapa de la nueva configuración (apartado c) — M1 y M2 sin cambios, los dos huecos libres A000H–BFFFH y C000H–DFFFH, y la ROM de 8 KB pegada al final del mapa con sus cuatro bancos de 2K×8.

📚 Tema 5, pág. 32 («no suele utilizarse la capacidad total de la memoria… puede quedar un buen número de posiciones vacías»): dejar huecos sin decodificar es legítimo y de hecho conveniente para simplificar el circuito.

d) Diagrama lógico completo incluyendo la ROM (1,0 puntos)

Dibujar a mano en el examen; el diagrama validado está justo al final de este apartado. Esta es la descripción con la que se dibuja:

  1. CPU: direcciones A15…A0 (16 líneas), datos D7…D0 (bidireccional), control R/W̄ (global).
  2. DEC 2–4 #1: select pin 1 = A15, pin 0 = A14; salidas Y0…Y3 (activas ALTO), con A14 ramificándose también al bus de direcciones de M1 (normal).
  3. OR: Y0 e Y1 → salida = CS de M1 (ALTA, sin burbuja).
  4. AND con burbuja: Y2 y A13 negada → salida = CS de M2 (ALTA).
  5. Módulo M1 (RAM 32K×8): CS = salida OR; R/W̄ global; direcciones A14–A0; D7–D0. M2 (RAM 8K×8): CS = salida AND; R/W̄; A12–A0; D7–D0.
  6. AND de habilitación común: Y3 · A13 → señal EN_ROM (ventana E000H–FFFFH).
  7. DEC 2–4 #2: entradas A12 (pin 1) y A11 (pin 0) con enable EN_ROM (activo ALTO); salidas = CS de los 4 bancos. Alternativa equivalente y válida: 4 AND de 4 entradas (supuesto 3).
  8. Bancos ROM1–ROM4: cada uno 2 chips 2K×4 en paralelo compartiendo CS y A10–A0; chip «alto» a D7–D4, chip «bajo» a D3–D0; las ROM no llevan WE (la R/W̄ solo va a las RAM).

El diagrama montado (la descripción anterior dibujada: dos decodificadores 2–4 en cascada, una OR, tres AND con sus burbujas, y los seis módulos con sus CIs en paralelo):

Diagrama lógico completo (apartado d): decodificación en dos niveles y ampliación ROM 2K×4 CPU · direcciones A15-A0 (16) · datos D7-D0 (8, bidir) R/W‾ global → M1 y M2 (las ROM no tienen WE) A13 con barra = NOT(A13) · A12 y A11 solo para la ROM A14 va a la vez al DEC1 (pin 0) y a M1 (normal) DEC 2-4 #1 activo ALTO pin 1 = A15 · pin 0 = A14 A15 (pin 1) A14 (pin 0) A13 con barra A13 sin barra A12 (DEC2 pin 1) A11 (DEC2 pin 0) bus de direcciones Y0 Y1 Y2 Y3 CS_M1 = Y0 + Y1 (OR) CS_M2 = Y2 · NOT(A13) EN = Y3 · A13 DEC 2-4 #2 activo ALTO, con EN pin 1 = A12 · pin 0 = A11 CS_R1 CS_R2 CS_R3 CS_R4 M1 · RAM 32K×8 · CS ALTA CS = NOT(A15) [= Y0 + Y1] internas A14-A0 · datos D7-D0 M2 · RAM 8K×8 · CS ALTA CS = Y2 · NOT(A13) internas A12-A0 · datos D7-D0 ROM banco 1 · E000H-E7FFH chip D7-D4 2K×4 · A10-A0 chip D3-D0 2K×4 · A10-A0 ROM banco 2 · E800H-EFFFH chip D7-D4 2K×4 · A10-A0 chip D3-D0 2K×4 · A10-A0 ROM banco 3 · F000H-F7FFH chip D7-D4 2K×4 · A10-A0 chip D3-D0 2K×4 · A10-A0 ROM banco 4 · F800H-FFFFH chip D7-D4 2K×4 · A10-A0 chip D3-D0 2K×4 · A10-A0 bus de datos D7-D0 (8, bidireccional): M1 y M2 reciben los 8; en los bancos, chip alto D7-D4 y chip bajo D3-D0 Cada banco ROM = 2 chips 2K×4 en paralelo (comparten CS, A10-A0 y la ventana de banco); 4 bancos = 8 chips. Las ROM no llevan R/W‾. EN = Y3 · A13: CS_R1..R4 = EN decodificando A12,A11 (banco 1 = NOT·NOT, 2 = NOT·A11, 3 = A12·NOT, 4 = A12·A11); la OR da CS_M1 = NOT(A15). La AND con burbuja da CS_M2 = Y2 · NOT(A13), igual que en la figura original. Todo verificado por barrido del VHDL del apartado e).

Figura: diagrama lógico completo (apartado d) con la ampliación: CPU, DEC 2–4 #1 sobre A15/A14, OR a la CS de M1, AND con NOT(A13) a la CS de M2, AND de habilitación común EN = Y3·A13, DEC 2–4 #2 con enable sobre A12/A11, y los cuatro bancos ROM de dos chips 2K×4 en paralelo.

📚 Tema 1, pág. 4 (decodificadores en cascada: «seleccionar uno entre los decodificadores de salida» con un segundo decodificador que recibe «las variables de mayor peso» — exactamente la estructura de dos 2:4 en cascada del diagrama; el ejemplo del tema obtiene un 4–16 con 2:4 igual que aquí se obtienen 4 bancos con un 2:4+enable).

e) Módulo VHDL que sustituye el decodificador del mapa (FPGA) (0,5 puntos)

El apartado e) pide sustituir el circuito de decodificación del mapa por un módulo VHDL (síntesis en FPGA): debe cubrir el mapa nuevo — CS de M1, CS de M2 y las cuatro CS de bancos ROM, todas a nivel ALTO. Entradas: las líneas altas del bus (se toma el bus completo A15–A0 por comodidad y para poder barrerlo entero); R/W̄ y los buses de datos no van al decodificador.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;   -- comparaciones de vectores con enteros hex (Tema 5 p.36)

-- Decodificador completo del mapa con la ROM ampliada (mapa de 16 bits, 65.536 posiciones)
-- Forma de las transparencias (Tema 5 pags. 36-37): DIR + comparaciones when...else
entity dec_mapa is
    port (
        A        : in  std_logic_vector(15 downto 0);  -- bus de direcciones
        CS_M1    : out std_logic;                     -- 0000H-7FFFH, RAM 32K, CS ALTA
        CS_M2    : out std_logic;                     -- 8000H-9FFFH, RAM 8K, CS ALTA
        CS_ROM_1 : out std_logic;                     -- E000H-E7FFH, CS ALTA
        CS_ROM_2 : out std_logic;                     -- E800H-EFFFH, CS ALTA
        CS_ROM_3 : out std_logic;                     -- F000H-F7FFH, CS ALTA
        CS_ROM_4 : out std_logic                      -- F800H-FFFFH, CS ALTA
    );
end entity dec_mapa;

architecture Behaviour of dec_mapa is
    signal DIR : std_logic_vector(15 downto 0);   -- bus completo (aqui A ya es el bus entero;
                                                   -- con solo las altas: DIR <= A15 & ... & "000...0")
begin
    DIR <= A;
    CS_M1    <= '1' when DIR <= 16#7FFF# else '0';                        -- 0000H-7FFFH
    CS_M2    <= '1' when DIR >= 16#8000# and DIR <= 16#9FFF# else '0';    -- 8000H-9FFFH
    CS_ROM_1 <= '1' when DIR >= 16#E000# and DIR <= 16#E7FF# else '0';    -- E000H-E7FFH
    CS_ROM_2 <= '1' when DIR >= 16#E800# and DIR <= 16#EFFF# else '0';    -- E800H-EFFFH
    CS_ROM_3 <= '1' when DIR >= 16#F000# and DIR <= 16#F7FF# else '0';    -- F000H-F7FFH
    CS_ROM_4 <= '1' when DIR >= 16#F800# and DIR <= 16#FFFF# else '0';    -- F800H-FFFFH
end architecture Behaviour;

Las ecuaciones puerta-a-puerta del apartado d) (Y0…Y3, la OR de M1, CS_M2 = Y2·NOT(A13), en_rom = Y3·A13 y los productos de banco) siguen siendo la justificación del diseño: el módulo de arriba es su traducción a la forma de las transparencias — comparaciones de rango sobre DIR en lugar de productos de salidas de decodificador; ambas descripciones son el mismo decodificador (cada rango es exactamente el producto Yn··· que genera la señal). En el examen vale cualquiera de las dos; la forma when...else con 16#…# es la que aparece en Tema 5 págs. 36–37. Los huecos A000H–BFFFH y C000H–DFFFH no aparecen en ninguna comparación: ahí no activa ninguna CS.

Verificación realizada (GHDL 4.1.0, --std=08 -fsynopsys). El módulo se simuló con un testbench que genera las expectativas por rangos (de la tabla del apartado b), independientemente de las comparaciones del diseño: barrido exhaustivo de las 65 536 direcciones = 65 536 comprobaciones, 0 fallos y 0 solapes (en cada dirección activa exactamente una CS o ninguna), con conteo acumulado por señal: M1 = 32 768, M2 = 8 192, bancos ROM = 2 048 cada uno (8 192 en total), huecos A000H–BFFFH = 8 192 y C000H–DFFFH = 8 192 ninguna CS activa; suma total = 65 536. Idéntico al conteo del TB anterior (que además generaba segmentos de ±160 direcciones alrededor de las 16 fronteras y un modelo Python paralelo; esa parte no se re-ejecutó — registrado en NOTAS). Scripts: dec_mapa.vhd, tb_dec_mapa.vhd en ~/.hermes/cache/scratch/vhdl-sep22/.

📚 Tema 5, págs. 36–37 (descripción VHDL de la decodificación del mapa de memoria, versiones 1 y 2: el módulo del apartado e es el mismo patrón, con las ecuaciones de habilitación como funciones combinacionales del bus de direcciones) y pág. 40 (habilitaciones de los integrados que forman parte del mapa y opciones de decodificación).

Errores típicos — P3

Baremo real del problema

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

Esquema-resumen de la metodología

  1. Leer la figura pin a pin, no adivinar — select del 2–4 (pin 1 = A15, pin 0 = A14), salidas a puertas (Y0+Y1→OR, Y2 y NOT(A13)→AND, Y3 suelta), CS sin burbuja = ALTA y, sobre todo, las líneas de dirección de cada bloque: la capacidad no está rotulada, sale de los pines (M1 A14–A0 → 32K×8, M2 A12–A0 → 8K×8).
  2. Montar el mapa desde las ecuaciones de CS — CS M1 = Y0+Y1 = NOT(A15) → 0000H–7FFFH; CS M2 = Y2·NOT(A13) → 8000H–9FFFH; lo que ningún término decodifica queda libre (A000H–BFFFH y C000H–FFFFH con Y3 suelta): huecos = 8 192 + 16 384 y suma total = 65 536 sin solapes.
  3. Comprobar cabida y factibilidad de la ampliación — 8 KB anclada en FFFFH → E000H–FFFFH; requiere Y3 (libre) y A13=1 en la ventana; A12 y A11 no los usa nadie en esa zona → la decodificación disponible basta y no hay solape con M1/M2: la ampliación es posible y se declara en el enunciado.
  4. Dimensionar los chips con las dos expansiones — palabras: 8K/2K = 4 bancos; bits: bus de 8 y chip de 4 → 2 chips en paralelo (D7–D4 y D3–D0) compartiendo CS e internas A10–A0; total 8 chips 2K×4; cada banco exactamente 2 048 direcciones.
  5. Cascada de decodificación con enable — primer 2–4 sobre A15, A14 (existente); para la ROM, AND de habilitación común Y3·A13 y segundo 2–4 sobre A12, A11 (o 4 AND de 4 entradas): bancos E000H–E7FFH, E800H–EFFFH, F000H–F7FFH y F800H–FFFFH; sin el enable los bancos aparecerían por todo el mapa.
  6. Sintetizar y barrer — VHDL con las mismas ecuaciones (Yn, en_rom y los productos de banco); GHDL con un TB que genera expectativas por rangos: segmentos en las 16 fronteras + barrido de las 65 536 (70 352 checks, 0 fallos) y modelo Python de conteo por bloque: 32 768/8 192/4×2 048, huecos 8 192+8 192, solapes 0, total 65 536.

Idea transversal: el decodificador existente es un recurso, no un adorno — la ampliación se diseña desde la salida libre (Y3) y las líneas no consumidas (A13, A12, A11), y tanto el mapa heredado como el nuevo se validan barriendo las 65.536 direcciones en busca de solapes y fronteras, no probando cuatro direcciones sueltas.

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.