Guía de resolución — Examen de Sistemas Digitales II, Julio 2025 (18-07-2025)
Guía modelo para preparar la convocatoria de nov-dic 2026. El examen tiene 3 problemas: máquina expendedora ASM + VHDL (4 p), PicoBlaze para el mismo problema (2,5 p) y mapa de memoria (3,5 p).
Importante: el profesor no puntúa ejercicios mal planteados. Escribe siempre el planteamiento (2-3 frases) antes de desarrollar, justifica cada elección y deja verificable el resultado final (tablas, direcciones, código).
Problema 1 — Máquina expendedora "ponchis": ASM + VHDL (4 puntos)

Planteamiento. Es una máquina de estados con un contador binario de importe acumulado (máximo posible 5+5 = 10 → bastan 4 bits, rango 0–15): cada ficha insertada suma 1, 2 o 5. En cuanto el acumulado alcanza o supera 6 se entrega el producto un solo ciclo, el contador pasa a contener el exceso (importe − 6) y unos estados de devolución lo descomponen golosamente en fichas de 5, 2 y 1, emitiendo un pulso de un ciclo por ficha devuelta, hasta volver a ESPERA. Así se cumplen a la vez: un solo producto, cambio exacto, salidas de un ciclo y máquina lista de nuevo.
Datos que fija el enunciado y decisiones de diseño. Fija el enunciado: el precio
del producto (6 ponchis), las fichas admitidas (1, 2 y 5 ponchis, activas a
nivel alto, solo puede insertarse una ficha a la vez y entre fichas la señal del
lector vuelve a cero), las salidas ENTREGAR, D1, D2 y D5 —todas deben activarse
durante un solo ciclo de reloj, y si hay que devolver más de una ficha se hacen
seguidas una de otra—, y el comportamiento a)-e): acepta fichas, devuelve el cambio si
se excede, entrega al alcanzar o superar el precio, solo entrega un producto y queda
preparada de nuevo. Baremo: a) diagrama ASM: 2,5 p · b) módulo VHDL: 1,5 p.
Decisiones de diseño (no las fija el enunciado): representar el importe acumulado con
un contador binario en lugar de codificarlo en los estados; los nombres de los 7
estados (ESPERA, COMPRUEBA, ENTREGA, CALCAMBIO, DEVUELVE_5, DEVUELVE_2,
DEVUELVE_1); la descomposición golosa del cambio en fichas de 5, 2 y 1; y el
reset opcional del VHDL (el ASM no lo pide).
Datos y rango del cambio
| Salida | Acción (1 solo ciclo de reloj) |
|---|---|
| ENTREGAR | entrega el producto (precio 6) |
| D5 / D2 / D1 | devuelve una ficha de 5 / 2 / 1 ponchis |
Entradas: F1, F2, F5 activas a nivel alto, una ficha a la vez.
El importe solo puede crecer mientras esté por debajo de 6 (máx 5) y la ficha que lo alcanza vale como mucho 5 → importe máximo 10 → exceso máximo 4. El desglose goloso del cambio es:
| Exceso (importe−6) | Devoluciones (un pulso cada una) |
|---|---|
| 0 | ninguna |
| 1 | D1 |
| 2 | D2 |
| 3 | D2 y luego D1 |
| 4 | D2 y luego D2 |
Comentario de nivel: con precio 6 y fichas 1/2/5 el estado DEVUELVE_5 nunca llega a dispararse (cambio ≤ 4), pero el diseño lo incluye porque la salida D5 existe y el diagrama queda correcto para cualquier precio/fichas — así se pide en clase.
a) Diagrama ASM — 7 estados (2,5 p)
Bloques ASM (uno por estado; entre corchetes las salidas activas del estado; "ninguna transición" = permanecer en el estado; las acciones ← son cargas del contador IMPORTE, registradas al flanco):
| # | Estado (bloque ASM) | Salida | Decisiones → siguiente estado (acción) |
|---|---|---|---|
| 1 | ESPERA |
— | F1=1 → COMPRUEBA (IMPORTE←IMPORTE+1); F2=1 → COMPRUEBA (+2); F5=1 → COMPRUEBA (+5); nada → ESPERA |
| 2 | COMPRUEBA |
— | IMPORTE≥6 → ENTREGA; IMPORTE<6 → ESPERA |
| 3 | ENTREGA |
ENTREGAR | sin decisión (1 ciclo): IMPORTE←IMPORTE−6 → CALCAMBIO |
| 4 | CALCAMBIO |
— | IMPORTE≥5 → DEVUELVE_5; ≥2 → DEVUELVE_2; ≥1 → DEVUELVE_1; =0 → ESPERA |
| 5 | DEVUELVE_5 |
D5 | sin decisión (1 ciclo): IMPORTE←IMPORTE−5 → CALCAMBIO |
| 6 | DEVUELVE_2 |
D2 | sin decisión (1 ciclo): IMPORTE←IMPORTE−2 → CALCAMBIO |
| 7 | DEVUELVE_1 |
D1 | sin decisión (1 ciclo): IMPORTE←IMPORTE−1 → CALCAMBIO |
Claves del planteamiento (puntos del enunciado):
- Las acciones de suma van en las ramillas de decisión de ESPERA (caja de
acción sobre la rama SÍ); no hacen falta estados SUMA1/SUMA2/SUMA5 aparte.
- La decisión IMPORTE≥6 se comparte para todos los caminos → estado COMPRUEBA.
- Cada estado de salida (ENTREGA, DEVUELVE_x) dura exactamente 1 ciclo porque
su transición de salida no tiene condición: así cada salida pulsa un solo reloj.
- El cambio se emite de una en una ficha (D2 dos veces para el exceso 4),
seguidas una de otra, separadas solo por el estado de decisión CALCAMBIO.
- Tras el último pulso, CALCAMBIO ve IMPORTE=0 y vuelve a ESPERA: la máquina
queda preparada sola (apartado e).
- IMPORTE nunca necesita reset explícito en funcionamiento normal: las restas lo
dejan a 0. (En VHDL el reset síncrono es obligatorio en la traducción Tema 3, ver
código.)
Ejemplo de recorrido (5+5 = 10, cambio 4): ESPERA →(F5) COMPRUEBA[5] →ESPERA →(F5) COMPRUEBA[10] →ENTREGA(ENTREGAR=1, IMPORTE←4) →CALCAMBIO →DEVUELVE_2(D2, 2) →CALCAMBIO →DEVUELVE_2(D2, 0) →CALCAMBIO →ESPERA.
📚 Teoría: Tema 3, pág. 15–19 del PDF «Tema 3 SD-II_20200413.pdf» — diagramas ASM: cajas de estado, decisiones y salidas. 📚 Teoría: Tema 3, pág. 22 del PDF «Tema 3 SD-II_20200413.pdf» — diagrama de estados y diagrama ASM equivalentes.
b) Módulo VHDL del ASM (1,5 p)
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL; -- aritmética de vectores, como en los apuntes
entity Expendedora is
port (
clk : in std_logic; -- reloj del sistema
reset : in std_logic; -- puesta a cero (nivel alto)
F1, F2, F5 : in std_logic; -- fichas de 1, 2 y 5 (nivel alto)
ENTREGAR : out std_logic; -- entrega el producto
D5, D2, D1 : out std_logic -- devuelven una ficha de 5, 2 y 1
);
end entity Expendedora;
architecture ASM of Expendedora is
-- nombres de estado = nombres de los bloques del diagrama ASM
type mis_estados is (ESPERA, COMPRUEBA, ENTREGA, CALCAMBIO,
DEVUELVE_5, DEVUELVE_2, DEVUELVE_1);
signal estado : mis_estados;
-- contador de importe acumulado: max 5+5 = 10 -> vector de 4 bits (0..15)
signal importe : std_logic_vector(3 downto 0);
begin
------- proceso secuencial UNICO = ASM completo -------
process
begin
wait until clk = '1';
if reset = '1' then
estado <= ESPERA; importe <= "0000";
ENTREGAR <= '0'; D5 <= '0'; D2 <= '0'; D1 <= '0';
else
case estado is
when ESPERA => -- esperando una ficha
ENTREGAR <= '0'; D5 <= '0'; D2 <= '0'; D1 <= '0';
if F1 = '1' then
importe <= importe + 1; estado <= COMPRUEBA;
elsif F2 = '1' then
importe <= importe + 2; estado <= COMPRUEBA;
elsif F5 = '1' then
importe <= importe + 5; estado <= COMPRUEBA;
end if;
when COMPRUEBA => -- ¿alcanzado o superado el precio?
ENTREGAR <= '0'; D5 <= '0'; D2 <= '0'; D1 <= '0';
if importe >= 6 then estado <= ENTREGA;
else estado <= ESPERA;
end if;
when ENTREGA => -- un ciclo: ENTREGAR a 1
ENTREGAR <= '1'; D5 <= '0'; D2 <= '0'; D1 <= '0';
importe <= importe - 6; -- importe pasa a ser el exceso
estado <= CALCAMBIO;
when CALCAMBIO => -- descomposicion golosa del exceso
ENTREGAR <= '0'; D5 <= '0'; D2 <= '0'; D1 <= '0';
if importe >= 5 then estado <= DEVUELVE_5;
elsif importe >= 2 then estado <= DEVUELVE_2;
elsif importe >= 1 then estado <= DEVUELVE_1;
else estado <= ESPERA; -- cambio dado
end if;
when DEVUELVE_5 => -- un ciclo: D5 a 1
ENTREGAR <= '0'; D5 <= '1'; D2 <= '0'; D1 <= '0';
importe <= importe - 5;
estado <= CALCAMBIO;
when DEVUELVE_2 => -- un ciclo: D2 a 1
ENTREGAR <= '0'; D5 <= '0'; D2 <= '1'; D1 <= '0';
importe <= importe - 2;
estado <= CALCAMBIO;
when DEVUELVE_1 => -- un ciclo: D1 a 1
ENTREGAR <= '0'; D5 <= '0'; D2 <= '0'; D1 <= '1';
importe <= importe - 1;
estado <= CALCAMBIO;
when others =>
estado <= ESPERA; importe <= "0000";
ENTREGAR <= '0'; D5 <= '0'; D2 <= '0'; D1 <= '0';
end case;
end if;
end process;
end architecture ASM;
Notas para el examen: UN solo proceso secuencial con wait until clk='1', con las
cuatro salidas escritas en todas las ramas (cada una vale 1 justo el ciclo de su
estado: la transición de salida no tiene condición) y importe en std_logic_vector
con STD_LOGIC_UNSIGNED — comparas importe >= 6 y sumas/restas sin conversiones, que
es como se escribe en los apuntes; el rango se justifica igual (máximo acumulado 5+5=10
en el examen, 4 bits de holgura). El reset síncrono es obligatorio (Tema 3, pág.
30–32): deja ESPERA con importe 0 y las salidas en reposo.
La suma del importe dentro de la rama de ESPERA (en lugar de un proceso contador aparte) es la traducción literal de la caja de acción sobre la ramilla del ASM.
Verificado con GHDL 4.1.0 (--std=08 -fsynopsys) sobre el bloque de arriba, analizado
literal, con un testbench que solo observa puertos. Ojo con una sutileza del diseño que
la TB caza: la máquina es reactiva — compra en el primer total ≥ 6, y como el
parcial previo vale como mucho 5, la suma que cruza el precio está entre 6 y 10: los
excesos alcanzables son 0–4 y la rama DEVUELVE_5 es defensiva (no se dispara en
ningún escenario legal). Escenarios comprobados: 6 en dos cruces exactos (5+1 y 2+2+2)
con cambio 0; 7→D1; 8 (1+2+5)→D2; 9 (2+2+5)→D2+D1; 10 (5+5)→D2+D2; 1 y 2+2 sin llegar
al precio (nada se entrega); dos compras seguidas sin reset (el importe queda 0 y la
máquina vuelve sola a ESPERA); reset a mitad de la cadena de cambio (corta el segundo
D2 y la máquina sigue viva después); y un monitor paralelo que exige que toda salida
dure exactamente un ciclo en todo el paseo — 12 secuencias, TEST PASSED. El banco
del testbench anterior (con integer range y proceso combinacional) no se ha
re-ejecutado: la TB descrita es nueva sobre la estructura nueva.
📚 Teoría: Tema 3, pág. 23–24 del PDF «Tema 3 SD-II_20200413.pdf» — diagrama ASM y módulo VHDL equivalente. 📚 Teoría: Tema 3, pág. 30–32 del PDF «Tema 3 SD-II_20200413.pdf» — traducción de ASM a VHDL (sistema antirrebote). 📚 Teoría: Tema 2, pág. 50 del PDF «Tema 2 SD-II_20200317.pdf» — registro de E/S en paralelo: entrada de inicialización (Reset).
Errores típicos — P1
- Olvidar el contador y codificar el importe en los estados (haría falta 1 estado por cada importe parcial): el enunciado de la asignatura pide contador + estados de devolución.
- Salidas activas varios ciclos (p. ej. mantener D2=1 mientras quedan 2 fichas por devolver): el mecanismo expendedor cuenta activaciones, debe ser 1 pulso por ficha → estados DEVUELVE_x de un ciclo que vuelven a CALCAMBIO.
- Devolver el cambio con fichas de 1 siempre (cambio 4 = 4×D1): válido pero el profesor espera la descomposición golosa 5/2/1 (cambio 4 = D2+D2).
- No descontar el precio: tras ENTREGA el contador debe quedarse con el exceso, no con el total.
- Olvidar volver a ESPERA con IMPORTE=0 (apartado e: máquina preparada de nuevo).
- VHDL con estados S0, S1…: los nombres deben coincidir con los bloques ASM.
- Proceso combinacional sin valores por defecto (latches) o
caseno completo. - Contador en 3 bits: no llega (hace falta representar hasta 10 → 4 bits).
Esquema-resumen de la metodología
- Separar lo que fija el enunciado de las decisiones de diseño — fija: precio 6, fichas 1/2/5 (una a la vez) y salidas ENTREGAR/D1/D2/D5 de un solo ciclo y seguidas; se decide: contador binario del importe (en vez de codificarlo en los estados), nombres de los 7 estados, desglose goloso del cambio y el
resetopcional del VHDL. - Dimensionar el contador con el importe máximo posible — por debajo de 6 solo crece (máx 5) y la ficha que lo alcanza vale como mucho 5 → importe máx 10 → 4 bits (rango 0–15) y exceso máx 4.
- Tabular el cambio antes de dibujar — exceso (importe−6) 0–4 → devoluciones golosas en fichas de 5/2/1 con un pulso cada una: 1→D1; 2→D2; 3→D2+D1; 4→D2+D2.
- Dibujar la ASM con un bloque por estado y nombres propios — ESPERA, COMPRUEBA, ENTREGA, CALCAMBIO, DEVUELVE_5/2/1; las sumas van en las ramillas de ESPERA (sin estados SUMA aparte) y la decisión IMPORTE≥6 se comparte en COMPRUEBA.
- Hacer que cada salida dure 1 ciclo — los estados de salida (ENTREGA, DEVUELVE_x) llevan transición sin condición → exactamente un reloj de pulso por ficha (el mecanismo contador cuenta activaciones).
- Cerrar el ciclo de devolución y la puesta a punto — tras cada ficha devuelta se vuelve a CALCAMBIO (IMPORTE←IMPORTE−5/2/1); al ver IMPORTE=0 se va a ESPERA: la máquina queda preparada sola (apartado e) sin reset explícito.
- Recorrer un ejemplo sobre el diagrama — 5+5 = 10: ENTREGAR=1, IMPORTE←4 y dos D2 seguidos hasta ESPERA; se comprueban importes y devoluciones.
- Traducir a VHDL 1:1 con la ASM —
type mis_estadoscon los nombres de los bloques ASM; UN proceso secuencial conwait until clk='1'yresetsíncrono, con elcasedel ASM y todas las salidas escritas en cada rama (una salida que no se escribe, se memoriza). - Testbenchar los casos borde — 12 secuencias GHDL: precio exacto en dos cruces, excesos 0–4 (la máquina es reactiva: compra al primer total ≥ 6, así que el cruce cae entre 6 y 10), fichas que no llegan al precio, compras consecutivas y
reseta mitad de la cadena de cambio; verificar con monitor paralelo que cada salida está a 1 exactamente un ciclo y el recuento de fichas devueltas.
Idea transversal: el importe en un contador (no en los estados) mantiene la ASM en 7 estados pase lo que pase con los importes, y toda salida que debe durar un solo reloj es un estado con transición sin condición; ASM y VHDL son el mismo diseño dicho dos veces, con los mismos nombres estado a estado.
Problema 2 — PicoBlaze para la expendedora (2,5 puntos)


Planteamiento. El mismo problema 1 se resuelve con un PicoBlaze (núcleo KCPSM6 embebido en FPGA): el importe acumulado se guarda en un registro del micro (s0), las fichas se leen de un puerto de entrada (F1=bit0, F2=bit1, F5=bit2) y las salidas se escriben a un puerto de salida (bit0=ENTREGAR, bit1=D5, bit2=D2, bit3=D1). El programa es un bucle que codifica los primeros 5 estados del diagrama ASM obtenido en el problema anterior —en esta guía son los cinco primeros del ASM del apartado 1a: ESPERA, COMPRUEBA, ENTREGA, CALCAMBIO y DEVUELVE_5—. La ROM de programa es EXTERNA al núcleo y debe aparecer en el diagrama.
Datos que fija el enunciado y decisiones de diseño. Fija el enunciado: el
baremo (diagrama hardware: 1 p · programa ensamblador debidamente comentado:
1,5 p), que el diagrama detalle «bien» las conexiones, las entradas y salidas y
la memoria de programa, que el programa codifique los primeros 5 estados del
diagrama ASM obtenido en el problema anterior (cuáles son los 5 primeros los fija
el ASM de cada alumno; aquí son ESPERA, COMPRUEBA, ENTREGA, CALCAMBIO y
DEVUELVE_5) y la tabla de instrucciones impresa en el propio examen, que es la
referencia obligatoria de los mnemónicos: puertos como IN sX,kk / IN sX,(sY) y
OUT sX,kk / OUT sX,(sY) (las únicas formas de puerto que imprime la tabla),
ADD y ADDC como instrucciones distintas (ídem SUB/SUBC), y saltos
JUMP etiq / JUMP (N)Z, etiq / JUMP (N)C, etiq. Decisiones de diseño (no las fija el
enunciado): F1/F2/F5 agrupadas en un puerto de entrada H"00" (bits 0-2) y
ENTREGAR/D5/D2/D1 en un puerto de salida H"00" (bits 0-3), ambos decodificados
con port_id; no usar interrupciones (interrupt_port sin conectar); ROM de
programa externa de 1024×18; sin uso de la RAM scratchpad; y la convención de
flags que se declara en el programa: COMP/SUB dejan CY=1 si no hay préstamo
(la tabla no fija ese convenio).
a) Diagrama hardware (1 p) — descripción detallada
- Bloque KCPSM6 (firmcore PicoBlaze, dentro de la FPGA) con sus puertos:
clk,reset,input_port(7:0),output_port(7:0),port_id(7:0),read_strobe,write_strobe(en KCPSM6 esoutput_port_strobe(7:0)), y las líneas de la ROM de programa:program_port_addr(9:0)yprogram_port_instruction(17:0). La entradainterrupt_portse deja sin usar. - Memoria de programa: ROM 1024 × 18 (block RAM de la FPGA) — NO está dentro del núcleo: direcciones 000H–3FFH contienen las instrucciones de 18 bits. Dibujar SIEMPRE esta ROM junto al núcleo (vale parte del punto).
- Puerto de entrada (aislamiento con TEST): las líneas F1, F2, F5 del lector
conectadas a los bits 0, 1 y 2 de
input_port; el resto de bits a 0. La decodificación deport_id= H"00" conread_strobehabilita ese multiplexor. - Puerto de salida:
output_port(7:0)va a registros/latches de salida habilitados por el comparador deport_id= H"00" AND la línea de strobe; de los bits 0-3 salen ENTREGAR, D5, D2 y D1 hacia los mecanismos. - Reloj y reset del núcleo conectados. Sin bus de direcciones externo: el "bus de
E/S" del PicoBlaze es
input_port/output_port(8 bits) +port_id.
Figura: diagrama hardware del PicoBlaze (KCPSM6) con su ROM de programa externa y la lógica de puertos H"00" (apartado a).
📚 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 ensamblador comentado (1,5 p)
Programa ejecutado sobre un emulador KCPSM con secuencias completas de fichas, ciñéndose a la tabla de instrucciones impresa y a la convención de flags declarada: los pulsos de salida y el estado final coinciden con el ASM del problema 1.
;=====================================================================
; Expendedora "ponchis" (precio 6) - PicoBlaze KCPSM6
; Codifica los 5 primeros estados del ASM del problema 1:
; ESPERA, COMPRUEBA, ENTREGA, CALCAMBIO, DEVUELVE_5
; Puerto de entrada H"00": bit0=F1, bit1=F2, bit2=F5
; Puerto de salida H"00": bit0=ENTREGAR, bit1=D5, bit2=D2, bit3=D1
;=====================================================================
P_ENT EQU H"00" ; puerto del lector de fichas
P_SAL EQU H"00" ; puerto de mecanismos de entrega/devolucion
ORG H"000"
INICIO: LOAD s0, H"00" ; s0 = IMPORTE acumulado, empieza a 0
LOAD s7, H"00" ; s7 queda siempre a 0 (registro "cero" util)
; ------------- ESTADO 1: ESPERA (leer una ficha) -------------
ESPERA: IN s1, P_ENT ; leo el lector: F1=bit0, F2=bit1, F5=bit2
TEST s1, H"01" ; pruebo F1 (ficha de 1)
JUMP Z, CHEQ_F2 ; Z=1 -> F1 era 0: pruebo la siguiente ficha
COMP s7, H"01" ; 0-1 presta: deja CY=0 (defensivo: la tabla
; distingue ADD de ADDC; ADD no toma la CY)
ADD s0, H"01" ; IMPORTE = IMPORTE + 1
JUMP COMPRUEBA
CHEQ_F2:TEST s1, H"02" ; pruebo F2 (ficha de 2)
JUMP Z, CHEQ_F5 ; Z=1 -> F2 era 0
COMP s7, H"01" ; CY=0 (defensivo: ADD suma sin mirar la CY)
ADD s0, H"02" ; IMPORTE = IMPORTE + 2
JUMP COMPRUEBA
CHEQ_F5:TEST s1, H"04" ; pruebo F5 (ficha de 5)
JUMP Z, ESPERA ; no hay ficha insertada: sigo esperando
COMP s7, H"01" ; CY=0 (defensivo)
ADD s0, H"05" ; IMPORTE = IMPORTE + 5
JUMP COMPRUEBA
; ------------- ESTADO 2: COMPRUEBA -------------
COMPRUEBA:
COMP s0, H"06" ; ¿IMPORTE >= 6? COMP deja CY=1 si no hay presto
JUMP C, ENTREGA ; CY=1 -> precio alcanzado o superado
JUMP ESPERA ; aun no llega: a por la siguiente ficha
; ------------- ESTADO 3: ENTREGA -------------
ENTREGA:
LOAD s2, H"01" ; s2 = 0000_0001: solo ENTREGAR
OUT s2, P_SAL ; entrego el producto (una sola pasada = 1 clk)
SUB s0, H"06" ; IMPORTE -= 6 exacto: SUB no toma la CY entrada
JUMP CALCAMBIO
; ------------- ESTADO 4: CALCAMBIO -------------
CALCAMBIO:
COMP s0, H"05" ; ¿queda un cambio de al menos 5?
JUMP C, DEVUELVE_5 ; si -> ESTADO 5
COMP s0, H"02" ; (las pruebas >=2 y >=1 corresponden a los
COMP s0, H"01" ; estados DEVUELVE_2 y DEVUELVE_1: el baremo
; solo codifica los 5 primeros estados)
LOAD s2, H"00" ; cambio terminado: apago todas las salidas
OUT s2, P_SAL ; (dejan los puertos en reposo)
LOAD s0, H"00" ; IMPORTE = 0 para volver a empezar limpia
JUMP ESPERA ; maquina preparada de nuevo (apartado e)
; ------------- ESTADO 5: DEVUELVE_5 -------------
DEVUELVE_5:
LOAD s2, H"02" ; s2 = 0000_0010: solo D5
OUT s2, P_SAL ; devuelvo una ficha de 5 (un ciclo)
SUB s0, H"05" ; IMPORTE -= 5 (SUB resta sin tomar la CY)
JUMP CALCAMBIO ; y sigo devolviendo o vuelvo a ESPERA
Justificaciones que conviene escribir en el examen:
- Cada OUT se ejecuta una sola vez por visita al estado → cada salida
dura un ciclo (equivale al bloque ASM de un ciclo).
- COMP s0,H"06" deja CY=1 si no hay préstamo, es decir si s0≥6 (es la
convención de flags que se declara al programar: la tabla impresa no fija ese
convenio) → JUMP C hace la decisión ≥.
- La tabla impresa distingue ADD/ADDC y SUB/SUBC: ADD/SUB no toman
la CY de entrada (solo la producen, como acarreo o préstamo), y por eso suman y
restan exactas. Los COMP s7,H"01" previos a los ADD son defensivos: dejan
CY=0 por si se escribiera la variante con acarreo.
- La ruta corta de CALCAMBIO (cambio 1, 2, 3 o 4 → DEVUELVE_2/1) no se desarrolla
porque el baremo solo codifica los 5 primeros estados; se deja la cadena de
COMP y un salto a ESPERA comentándolo, y se pone LOAD s0,H"00" para que el
programa parcial no deje importe fantasma en s0.
Ejemplo comprobado en el emulador (5+5): tras la segunda ficha s0=10 → ENTREGA (ENTREGAR=1, s0←4) → CALCAMBIO (4<5) → ruta corta: salidas a 0, s0←0, ESPERA. Una segunda compra 1+5 entrega de nuevo (2 entregas en total, s0 final 0). Ruta forzado s0=11 para probar DEVUELVE_5: ENTREGAR + D5 con s0 final 0. ✔
📚 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
- No dibujar la ROM de programa 1024×18 externa al lado del núcleo.
- Olvidar
ORG H"000"/ EQU de puertos y escribir direcciones "a dedo". - Escribir formas de puerto distintas de las impresas: la tabla del examen solo
contiene
IN sX,kk/IN sX,(sY)yOUT sX,kk/OUT sX,(sY); los alias de los ensambladores comerciales no están impresos. Seguir SIEMPRE la tabla impresa, aunque el ensamblador del PC admita otros alias. - Atribuir a
ADD/SUBla lectura de la CY de entrada: la tabla imprimeADDC/SUBCcomo instrucciones aparte yADD/SUBsolo producen CY (acarreo/préstamo); usar unas por otras desajusta sumas y restas. TEST s1,H"01"pone Z=1 cuando el bit probado es 0: elJUMP Zva a la prueba de la ficha siguiente; al revés de lo que parece.- Codificar estados distintos de los 5 primeros de tu ASM del problema 1 o pasarte de estados: el baremo del programa es solo 1,5 p. Mantén los nombres EXACTOS de los estados del ASM del problema 1.
- Olvidar el
OUT s2,H"00"(apagar salidas) o no resetear s0 en la ruta corta: la máquina quedaría con importe fantasma y entregaría productos de balde. - Programa sin comentar línea a línea: ahí están los 1,5 puntos.
Esquema-resumen de la metodología
- Partir de la ASM del problema 1 y ceñirse a sus 5 primeros estados — el baremo codifica solo ESPERA, COMPRUEBA, ENTREGA, CALCAMBIO y DEVUELVE_5 (los 5 primeros del ASM de cada alumno): mantener los nombres exactos y no codificar los estados restantes, dejándolo declarado en comentarios.
- Decidir puertos y convenciones antes de programar — puerto de entrada H"00" (bit0=F1, bit1=F2, bit2=F5) y puerto de salida H"00" (bit0=ENTREGAR, bit1=D5, bit2=D2, bit3=D1); ROM externa 1024×18; sin interrupciones ni scratchpad; declarar la convención de flags que la tabla no fija (COMP/SUB dejan CY=1 si no hay préstamo).
- Dibujar el hardware con la ROM de programa fuera del núcleo — KCPSM6 con clk, reset, input_port/output_port(7:0), port_id y strobes; ROM 1024×18 (000H–3FFH, instrucciones de 18 bits) siempre junto al núcleo;
interrupt_portsin conectar. - Conectar entradas con aislamiento y salidas con latches — F1/F2/F5 a los bits 0–2 de
input_port(resto a 0) con el mux habilitado porport_id=H"00" yread_strobe;output_porta latches habilitados por el comparador deport_idAND la línea de strobe; ENTREGAR/D5/D2/D1 salen de los bits 0–3. - Encabezar el programa con ORG y EQU de puertos — nunca direcciones "a dedo"; un encabezado comentado por estado que explique qué y porqué (ahí están los 1,5 puntos).
- Codificar las decisiones del estado con TEST y COMP —
TESTcon máscara de bit (H"01"/H"02"/H"04"): Z=1 significa que el bit probado vale 0 →JUMP Za la prueba de la ficha siguiente;COMP s0,H"06"+JUMP Cpara la decisión ≥6 con la convención declarada. - Usar solo los mnemónicos de la tabla impresa —
IN/OUTúnicamente en forma kk o (sY);ADDyADDCson instrucciones distintas (ídemSUB/SUBC):ADD/SUBno toman la CY de entrada y por eso suman y restan exactas; losCOMP s7,H"01"previos son defensivos (dejan CY=0). - Hacer que cada OUT se ejecute una sola vez por visita al estado — un OUT = un pulso de un ciclo, equivalente al bloque ASM de un ciclo; en la ruta corta de CALCAMBIO apagar salidas con
OUT s2,H"00"y limpiar importe conLOAD s0,H"00"para no dejar importe fantasma. - Ejecutar el programa en un emulador KCPSM — 5+5 (s0=10: ENTREGAR, s0←4, ruta corta), segunda compra (2 entregas, s0 final 0) y s0=11 forzado para ver DEVUELVE_5 (ENTREGAR + D5): los pulsos de salida coinciden con la ASM del problema 1.
Idea transversal: la tabla de instrucciones impresa del examen es la única referencia de mnemónicos (IN/OUT kk, ADD≠ADDC, TEST con Z invertido) y el programa es literalmente la ASM del problema anterior: mismos estados con mismos nombres, un OUT por bloque de un ciclo, y lo que el baremo no pide se declara en comentarios en vez de inventárselo.
Problema 3 — Mapa de memoria (3,5 puntos)

Planteamiento. El bus de datos tiene 16 bits y hay 256K posiciones: cada posición es una palabra de 16 bits y el espacio de 2¹⁸ = 262 144 posiciones exige 18 líneas de dirección, A17…A0. Se colocan E/S1 (32K), E/S2 (64K) y RAM (48K) seguidos desde 0h en ese orden, y la PROM de 64K anclada al final del mapa; eso deja un hueco de 48K entre la RAM y la PROM. Con los CI disponibles (PROM 32K×16, RAM 16K×8) hay que hacer expansión de palabras y de bits y generar los CS con la polaridad de cada bloque.
Datos que fija el enunciado y decisiones de diseño. Fija el enunciado: bus de datos de 16 bits, espacio de direccionamiento máximo de 256K posiciones, los módulos E/S1 (32K), E/S2 (64K) y RAM (48K) seguidos y en ese orden desde la posición inicial 0h, la PROM de 64K que termina al final del mapa, las polaridades de control (E/S1 y E/S2: CE y RW activas a nivel bajo; RAM: CE alto y RW bajo; PROM: CE alto, sin mención de RW), los CI disponibles (PROM 32K×16, RAM 16K×8) y el baremo: tabla del mapa 1 p · diagrama lógico simplificado 1 p · módulo VHDL de decodificación 1,5 p. El hueco libre de 48K entre la RAM y la PROM no está impreso: se deduce de la colocación pedida (32K+64K+48K = 144K desde 0h y la PROM acaba en 3FFFFH). El mapa queda unívocamente fijado por el enunciado: no hay decisiones de diseño de relevancia, solo la forma de escribir el decodificador (que se comenta tras el VHDL).
Datos de partida
- 256K posiciones de 16 bits → 18 bits de dirección (A17–A0); direcciones hex de 5 dígitos, de 00000H a 3FFFFH.
- 256K = 0x40000; 32K = 0x8000; 48K = 0xC000; 64K = 0x10000.
- Polarity de control: E/S1 y E/S2: CE̅ (BAJO) y RW̅ (BAJO); RAM: CE ALTO y RW̅ (BAJO); PROM: CE ALTO.
a) Tabla del mapa de memoria (1 p)
Colocación pedida, comprobada: 32K+64K+48K = 144K desde 0h; la PROM de 64K acaba en 3FFFFH → empieza en 0x40000−0x10000 = 0x30000. Hueco = 0x30000−0x24000 = 0xC000 = 48K. Suma total = 262 144 = 256K (encaja exacto).
| Módulo | Tamaño | Inicial hex | Final hex | CE | RW |
|---|---|---|---|---|---|
| E/S1 | 32K | 00000H | 07FFFH | BAJO | BAJO |
| E/S2 | 64K | 08000H | 17FFFH | BAJO | BAJO |
| RAM | 48K | 18000H | 23FFFH | ALTO | BAJO |
| Hueco libre | 48K | 24000H | 2FFFFH | — | — |
| PROM | 64K | 30000H | 3FFFFH | ALTO | — |
Nº mínimo de CI (expansión de palabras × bits):
| Bloque | CI disponible | Palabras | Bits | Nº CI |
|---|---|---|---|---|
| PROM 64K×16 | PROM 32K×16 | 64K/32K = 2 | 16/16 = 1 | 2 (en cascada) |
| RAM 48K×16 | RAM 16K×8 | 48K/16K = 3 | 16/8 = 2 | 6 (3 grupos de 2 en paralelo) |
| E/S1 / E/S2 | módulos hechos | — | — | 1 + 1 |
Detalle por CI (nivel circuito, lo que exige el diagrama):
| CI | Direcciones | Selección (CE) | Líneas internas de dir. |
|---|---|---|---|
| E/S1 | 00000H–07FFFH | BAJO: A17A16A15 = 000 | A14–A0 |
| E/S2 | 08000H–17FFFH | BAJO: A17=0 y A16≠A15 | ver nota de alineación |
| RAM-A1,RAM-A2 (D7–D0 y D15–D8) | 18000H–1BFFFH | ALTO: A17..A14 = 0110 | A13–A0 |
| RAM-B1,RAM-B2 | 1C000H–1FFFFH | ALTO: A17..A14 = 0111 | A13–A0 |
| RAM-C1,RAM-C2 | 20000H–23FFFH | ALTO: A17..A14 = 1000 | A13–A0 |
| PROM-0 | 30000H–37FFFH | ALTO: A17A16A15 = 110 | A14–A0 |
| PROM-1 | 38000H–3FFFFH | ALTO: A17A16A15 = 111 | A14–A0 |
Trampa del problema: E/S1 mide solo 32K, así que E/S2 (64K) no queda alineada a frontera de 64K (empieza en 08000H): cruza la frontera de A16. Su selección necesita A15 además de A17,A16 (sectores de 32K nº1 y nº2). Para que el módulo de 64K (16 líneas internas de dirección) funcione, conecta sus entradas de dirección A14'–A0' a A14–A0 del CPU y su MSB A15' a A16 del CPU (mientras su CS está activo esa correspondencia es biyectiva sobre el rango 08000H–17FFFH). Escríbelo en el examen: demuestra que entiendes por qué la alineación importa.
📚 Teoría: Tema 5, pág. 32 del PDF «Tema 5 SD-II_20230215.pdf» — capacidad direccionable: m líneas del bus de direcciones. 📚 Teoría: Tema 5, pág. 33 del PDF «Tema 5 SD-II_20230215.pdf» — ejemplo de diseño de un mapa de memoria con RAM, ROM y E/S. 📚 Teoría: Tema 1, pág. 53–55 del PDF «Tema 1 SD-II_20200206.pdf» — memorias ROM/FLASH: organización en palabras de m bits (128K×8).
b) Diagrama lógico simplificado (1 p) — ecuaciones y descripción
Partición de las 18 líneas: los bloques de 32K consumen A14–A0 y los de 16K consumen A13–A0; la decodificación usa las 4 líneas altas A17–A14. Ecuaciones (nivel alto activo salvo donde se indica lo contrario; la barra sobre el término es el inversor correspondiente):
CS_ES1(BAJO) = A17 + A16 + A15 → 0 exactamente en 00000H–07FFFH (1 OR).CS_ES2(BAJO) = A17 + (A16 ⊙ A15) (A16 XNOR A15) → 0 solo con A17=0 y A16≠A15, es decir 08000H–17FFFH (1 XNOR + 1 OR).CS_RAM_A(ALTO) = A17̄ · A16 · A15 · A14̄ → 18000H–1BFFFH.CS_RAM_B(ALTO) = A17̄ · A16 · A15 · A14 → 1C000H–1FFFFH.CS_RAM_C(ALTO) = A17 · A16̄ · A15̄ · A14̄ → 20000H–23FFFH.CS_PROM0(ALTO) = A17 · A16 · A15̄ → 30000H–37FFFH.CS_PROM1(ALTO) = A17 · A16 · A15 → 38000H–3FFFFH.
En el hueco 24000H–2FFFFH (combinaciones A17A16A15=100 con A14=1, y 101) ninguna salida se activa: no hay que decodificarlo.
Figura: diagrama lógico simplificado del apartado b (mapa del apartado a y decodificación con las ecuaciones de arriba).
Dibujar: CPU con bus A17–A0 y bus de datos de 16 bits D15–D0 y línea R/W̄; A13–A0 a las RAM, A14–A0 a E/S1 y a las PROM (a E/S2 según la nota anterior); bloques decodificadores con las ecuaciones de arriba; cada CS a su CI/grupo; R/W̄ de la CPU directa a las patillas RW̅ de E/S1, E/S2 y los 6 RAM (la PROM no tiene RW). En cada grupo de 2 RAM, un CI conduce D7–D0 y el otro D15–D8 (comparten direcciones y CS).
📚 Teoría: Tema 5, pág. 34–35 del PDF «Tema 5 SD-II_20230215.pdf» — condiciones de habilitación de los bloques del mapa según las líneas de dirección. 📚 Teoría: Tema 1, pág. 3–5 del PDF «Tema 1 SD-II_20200206.pdf» — decodificador completo: n entradas y 2ⁿ salidas (minitérminos).
c) Módulo VHDL de la decodificación para FPGA (1,5 p)
Analizado con GHDL y simulado sobre el mapa completo: el módulo solo recibe A(17
downto 14), así que sus 16 patrones de entrada cubren las 262 144 direcciones (cada
patrón = un bloque de 16K): cada CS activo exactamente en su rango, ningún
solapamiento, hueco sin activar. Bloque intacto en el pase de estilo (el when/else
del Tema 5 pág. 36–37 es el estilo de los apuntes) y barrido re-ejecutado en GHDL
--std=08 -fsynopsys (12/11): ES1 en 2 patrones, ES2 en 4, cada CS_RAM en 1, cada
CS_PROM en 2, hueco en 3 (24000H–2FFFFH) y 0 solapes:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity Decodificador_Map is
port (
A : in std_logic_vector(17 downto 14); -- lineas altas de direccion
CS_ES1 : out std_logic; -- E/S1: activa a nivel BAJO
CS_ES2 : out std_logic; -- E/S2: activa a nivel BAJO
CS_RAM : out std_logic_vector(2 downto 0); -- RAM (3 grupos de 16K): ALTO
CS_PROM : out std_logic_vector(1 downto 0) -- PROM (2 CI de 32K): ALTO
);
end entity Decodificador_Map;
architecture Behaviour of Decodificador_Map is
begin
-- E/S1: 00000H-07FFFH (A17 A16 A15 = 0 0 0) CS activo a nivel BAJO
CS_ES1 <= '0' when A(17 downto 15) = "000" else '1';
-- E/S2: 08000H-17FFFH (A17=0 y A16 /= A15: sectores 001 y 010) CS BAJO
CS_ES2 <= '0' when (A(17) = '0' and (A(16) xor A(15)) = '1') else '1';
-- RAM 48K (CE ALTO): 3 grupos de 16K, uno por bit de CS_RAM
CS_RAM(0) <= '1' when A = "0110" else '0'; -- RAM-A 18000H-1BFFFH
CS_RAM(1) <= '1' when A = "0111" else '0'; -- RAM-B 1C000H-1FFFFH
CS_RAM(2) <= '1' when A = "1000" else '0'; -- RAM-C 20000H-23FFFH
-- PROM 64K (CE ALTO) al final del mapa: 2 CI de 32K, uno por bit de CS_PROM
CS_PROM(1) <= '1' when A(17 downto 15) = "110" else '0'; -- PROM-0 30000H-37FFFH
CS_PROM(0) <= '1' when A(17 downto 15) = "111" else '0'; -- PROM-1 38000H-3FFFFH
end architecture Behaviour;
Nota VHDL: si el profesor prefiere ver las ecuaciones como sumas de productos, se
puede escribir el mismo decodificador como ecuaciones booleanas directas sobre
A(17..14) (CS_RAM(0) <= (not A(17)) and A(16) and A(15) and not A(14); …); la
simulación es idéntica.
📚 Teoría: Tema 5, pág. 36–37 del PDF «Tema 5 SD-II_20230215.pdf» — descripción VHDL de la decodificación del mapa de memoria (dos versiones). 📚 Teoría: Tema 1, pág. 33–34 del PDF «Tema 1 SD-II_20200206.pdf» — decodificador de 3 a 8 líneas en VHDL, con línea de enable.
Errores típicos — P3
- Usar 16 líneas de dirección: 256K posiciones de 16 bits = 18 líneas A17–A0 (el bus de datos de 16 bits no reduce el espacio de direcciones).
- Poner la PROM pegada tras la RAM (en 24000H): el enunciado dice que termina al final del mapa → 30000H–3FFFFH; el hueco de 48K queda en medio.
- Olvidar la expansión de bits de la RAM: 16K×8 no llena los 16 bits del bus → cada grupo de 16K son 2 CI (total 6, no 3). Es lo primero que se comprueba.
- PROM: 64K = 2 CI de 32K en cascada, no 1; cada uno con su CS (A15 los distingue).
- Olvidar que E/S2 queda desalineada (E/S1 solo mide 32K) y seleccionarla solo con A17A16 → solaparía con E/S1 o con la RAM. La selección correcta usa A16≠A15.
- Confundir polaridades: E/S CS̅ (BAJO) y RAM/PROM CE (ALTO). En el VHDL el '0'/'1' activo de cada salida debe coincidir con la tabla del enunciado.
- Decodificar el hueco: no hace falta ninguna señal para 24000H–2FFFFH.
- Olvidar conectar RW̅ a E/S1, E/S2 y RAM (la PROM no lleva RW).
Esquema-resumen de la metodología
- Derivar las líneas de dirección del nº de posiciones — 256K posiciones de palabra de 16 bits → 2¹⁸ = 18 líneas A17–A0 y direcciones hex de 5 dígitos, 00000H–3FFFFH; el bus de datos de 16 bits no reduce el espacio de direcciones.
- Colocar los bloques donde el enunciado los fija — E/S1 (32K), E/S2 (64K) y RAM (48K) seguidos y en ese orden desde 00000H; la PROM de 64K anclada al final → empieza en 0x40000−0x10000 = 30000H y acaba en 3FFFFH.
- Comprobar con sumas y deducir el hueco — 32K+64K+48K = 144K terminan en 23FFFH; el hueco 24000H–2FFFFH (0x30000−0x24000 = 48K) no está impreso, se deduce, y el total encaja exacto en 256K.
- Rellenar la tabla con inicial, final y polaridades por bloque — E/S1 y E/S2: CE̅ y RW̅ nivel BAJO; RAM: CE ALTO y RW̅ BAJO; PROM: CE ALTO, sin RW; el hueco libre no se decodifica.
- Detectar la desalineación antes de elegir las CS — E/S1 mide solo 32K, así que E/S2 (64K) empieza en 08000H sin alinear a frontera de 64K y cruza A16: se selecciona con A17=0 y A16≠A15, y al módulo de 64K hay que conectarle su MSB A15' a A16 del CPU.
- Contar los CI con expansión de palabras × bits — PROM 64K×16: 2 CI de 32K×16 en cascada (los distingue A15); RAM 48K×16: 3 grupos de 16K con 2 RAM 16K×8 en paralelo cada uno (uno D7–D0, otro D15–D8) → 6 CI, no 3.
- Decodificar solo con las líneas altas A17–A14 y la polaridad de cada bloque — CS_ES1 (BAJO) = A17+A16+A15; CS_ES2 (BAJO) = A17+(A16 XNOR A15); cada grupo de RAM, producto de 4 términos (A17..A14 = 0110/0111/1000); cada PROM, producto de 3 (110/111).
- Dibujar el diagrama lógico completo — CPU con A17–A0, D15–D0 y R/W̄; direcciones por bloque (A14–A0 a E/S1 y PROM, A13–A0 a las RAM, E/S2 según la nota de alineación); cada CS a su CI/grupo; R/W̄ directa a E/S1, E/S2 y las 6 RAM (la PROM no lleva RW).
- Escribir el decodificador VHDL sobre A(17 downto 14) y barrer todo el mapa — una expresión por CS (o suma de productos equivalente); GHDL simula las 262 144 direcciones: cada CS activa exactamente en su rango, ningún solape y ninguna señal en el hueco.
Idea transversal: el orden impuesto y el anclaje de la PROM al final fijan el mapa sin decisiones — rangos y hueco se deducen sumando en hex, no a ojo; la alineación decide qué líneas seleccionan cada bloque (E/S2 desalineado es la trampa) y el decodificador se valida barriendo todo el espacio de direcciones en busca de solapes y fronteras, no solo direcciones de ejemplo.