Guía de resolución — Examen de Sistemas Digitales II, Junio 2026 (10-06-2026)
Guía modelo de resolución, para preparar la convocatoria de noviembre-diciembre de 2026. El examen tiene 3 problemas: mapa de memoria (3,5 p), diagrama ASM + VHDL (3,5 p) y PicoBlaze (3 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 — Mapa de memoria (3,5 puntos)
Planteamiento. El procesador direcciona 16K posiciones de 16 bits, es decir 16384 palabras con 14 líneas de dirección (A13–A0). Hay que colocar seis bloques (ROM 4K, EPROM, RAM, E/S-1 256, hueco 768, E/S-2 256) sin solapamiento, construir cada bloque con expansiones de palabras y de bits a partir de los CI disponibles, y generar las señales de habilitación (CS activa a nivel BAJO en memorias; CS1 y CS2 activas a nivel ALTO en E/S) decodificando las líneas altas de dirección.
Direcciones en hexadecimal con 14 bits: se escriben como 4 dígitos hex (equivalen a 16 bits con A15=A14=0, que no existen).
Datos que fija el enunciado y decisiones de diseño. Fija el enunciado: el espacio 16K×16 (16 384 posiciones de 16 bits → A13…A0), la ROM de 4K desde 0, los módulos E/S-1 y E/S-2 de 256 posiciones con hueco libre de 768 entre ellos, y los CIs disponibles (ROM 4K×8, EPROM 1K×16, RAM 4K×4, dos módulos de E/S). También la polaridad: CS de memorias activa a nivel BAJO; CS1 y CS2 de E/S activas a nivel ALTO, que se unen a la MISMA salida de decodificación (el AND interno del módulo queda satisfecho). No lo fija el enunciado: el tamaño de los bloques EPROM y RAM —el P1 no tiene figura, es 100 % textual—, que es por tanto decisión propia justificada (rango derivado en el apartado a). La guía desarrolla EPROM 4K + RAM 4K, opción redonda y coherente con los CIs (deja 2816 posiciones libres); con otro reparto válido solo cambian las direcciones y las señales de CS, no el método.
a) Demostrar que caben + nº de CI por bloque (0,5 p)
El enunciado fija ROM 4K, E/S 256, hueco 768 y E/S 256, pero no da el tamaño de EPROM y RAM: hay que elegirlo y justificarlo a partir de los CIs. En el examen no se memoriza un tamaño: se deriva el rango.
- Espacio que queda para EPROM + RAM: 16 384 − 4 096 (ROM) − 256 (E/S-1) − 768 (hueco) − 256 (E/S-2) = 11 008 posiciones.
- RAM (CIs de 4K×4): el bloque mínimo ×16 son 4 chips en paralelo (4K×16 = 4K posiciones); una segunda fila en cascada la sube a 8K×16 (8 chips). Tamaños admisibles: 4K u 8K (con 12K ya no dejaría sitio ni para la EPROM mínima).
- Con RAM 4K: EPROM de 1 a 6 chips de 1K (1K–6K), pues 4 096 + 6 144 = 10 240 ≤ 11 008, pero 4 096 + 7 168 = 11 264 desborda.
- Con RAM 8K: EPROM de 1 a 2 chips de 1K (1K–2K), pues 8 192 + 2 048 = 10 240 ≤ 11 008, pero 8 192 + 3 072 = 11 264 desborda.
La guía desarrolla el reparto EPROM 4K + RAM 4K para fijar mapa, tablas y VHDL; en el apartado c) se desarrolla la alternativa más relevante (EPROM 2K + RAM 8K).
Suma de posiciones necesarias (para el reparto desarrollado):
| Bloque | Posiciones |
|---|---|
| ROM 4K | 4096 |
| EPROM (elegido 4K; admisible 1K–6K con RAM 4K) | 4096 |
| RAM (elegido 4K; bloque mínimo ×16; admisible también 8K) | 4096 |
| E/S-1 | 256 |
| Hueco | 768 |
| E/S-2 | 256 |
| Total | 13 568 |
13 568 ≤ 16 384 → caben, y sobran 2 816 posiciones. Nótese que el hueco de 768 es justo 3 sub-bloques de 256: encaja en la región 0x3000–0x3FFF dividida en 16 sub-bloques de 256 seleccionados por A11…A8.
Nº mínimo de CI por bloque (expansión de palabras × expansión de bits):
| Bloque | Tamaño bloque | CI disponible | Palabras | Bits | Nº CI |
|---|---|---|---|---|---|
| ROM | 4K×16 | ROM 4K×8 | 4096/4096 = 1 | 16/8 = 2 | 2 (en paralelo) |
| EPROM | 4K×16 | EPROM 1K×16 | 4096/1024 = 4 | 16/16 = 1 | 4 (en cascada) |
| RAM | 4K×16 | RAM 4K×4 | 4096/4096 = 1 | 16/4 = 4 | 4 (en paralelo) |
| E/S-1 / E/S-2 | 256 c/u | módulos hechos | — | — | 1+1 |
Total: 10 CI de memoria + 2 módulos de E/S.
- Las dos ROM comparten direcciones y CS; una conduce D7–D0 y la otra D15–D8.
- Las cuatro RAM comparten direcciones y CS; cada una aporta 4 bits del bus (CI0: D3–D0, CI1: D7–D4, CI2: D11–D8, CI3: D15–D12).
- Las cuatro EPROM ocupan cada una 1K posiciones (aportan los 16 bits): se eligen por las líneas A11–A10.
- Estas cuentas corresponden al reparto elegido; con otro tamaño de EPROM solo cambia su fila (nº de CI EPROM = tamaño del bloque / 1K) y con RAM 8K la fila de RAM pasa a 8 chips (dos filas de 4 en paralelo, cascada ×2).
📚 Teoría: Tema 1, pág. 53 del PDF «Tema 1 SD-II_20200206.pdf» — organización de memorias: palabras de m bits. 📚 Teoría: Tema 1, pág. 54 del PDF «Tema 1 SD-II_20200206.pdf» — tipos de ROM: programables, PROM y EPROM. 📚 Teoría: Tema 5, pág. 32 del PDF «Tema 5 SD-II_20230215.pdf» — capacidad direccionable según el bus de direcciones.
b) Mapa de memoria del sistema (0,75 p)
Colocación en el orden pedido, todas las bases alineadas en potencias de 2:
0x0000 ┌────────────────────────────┐
│ ROM 4K (2 × ROM 4K×8) │
0x0FFF ├────────────────────────────┤
│ EPROM 4K (4 × EPROM 1K×16) │
0x1FFF ├────────────────────────────┤
│ RAM 4K (4 × RAM 4K×4) │
0x2FFF ├────────────────────────────┤
│ E/S-1 256 │
0x30FF ├────────────────────────────┤
│ Hueco 768 (= 3 × 256) │
0x33FF ├────────────────────────────┤
│ E/S-2 256 │
0x34FF ├────────────────────────────┤
│ libre 2816 │
0x3FFF └────────────────────────────┘
📚 Teoría: Tema 5, pág. 33 del PDF «Tema 5 SD-II_20230215.pdf» — ejemplo de diseño de mapa: RAM, ROM, E/S.
c) Tabla de direcciones inicial y final (0,75 p)
Binario son las 14 líneas A13…A0 (agrupadas 2+4+4+4 por legibilidad).
Por bloque:
| Bloque | Inicial (binario A13..A0) | Final (binario A13..A0) | Inicial hex | Final hex |
|---|---|---|---|---|
| ROM | 00 0000 0000 0000 |
00 1111 1111 1111 |
0000H | 0FFFH |
| EPROM | 01 0000 0000 0000 |
01 1111 1111 1111 |
1000H | 1FFFH |
| RAM | 10 0000 0000 0000 |
10 1111 1111 1111 |
2000H | 2FFFH |
| E/S-1 | 11 0000 0000 0000 |
11 0000 1111 1111 |
3000H | 30FFH |
| Hueco | 11 0001 0000 0000 |
11 0011 1111 1111 |
3100H | 33FFH |
| E/S-2 | 11 0100 0000 0000 |
11 0100 1111 1111 |
3400H | 34FFH |
| (libre) | 11 0101 0000 0000 |
11 1111 1111 1111 |
3500H | 3FFFH |
Por circuito integrado (nivel CI: lo que exige "cada circuito"):
| CI | Seleccionado por | Inicial hex | Final hex |
|---|---|---|---|
| ROM-0 (D7–D0) y ROM-1 (D15–D8) | A13A12 = 00 | 0000H | 0FFFH |
| EPROM-0 | A13A12A11A10 = 0100 | 1000H | 13FFH |
| EPROM-1 | 0101 | 1400H | 17FFH |
| EPROM-2 | 0110 | 1800H | 1BFFH |
| EPROM-3 | 0111 | 1C00H | 1FFFH |
| RAM-0..RAM-3 (todas) | A13A12 = 10 | 2000H | 2FFFH |
| E/S-1 (CS1,CS2) | A13..A8 = 110000 | 3000H | 30FFH |
| E/S-2 (CS1,CS2) | A13..A8 = 110100 | 3400H | 34FFH |
Reparto alternativo, igualmente válido: EPROM 2K + RAM 8K. Mismos bloques y orden; solo cambian direcciones y CS (EPROM: 2 CI de 1K×16, elegidos por A10; RAM: dos filas de 4 CI 4K×4 en paralelo, expansión de palabras ×2 = 8 CI):
| Bloque | Inicial hex | Final hex | Posiciones |
|---|---|---|---|
| ROM | 0000H | 0FFFH | 4096 |
| EPROM | 1000H | 17FFH | 2048 |
| RAM | 1800H | 37FFH | 8192 |
| E/S-1 | 3800H | 38FFH | 256 |
| Hueco | 3900H | 3BFFH | 768 |
| E/S-2 | 3C00H | 3CFFH | 256 |
| (libre) | 3D00H | 3FFFH | 768 |
Suma: 15 616 ≤ 16 384 (libres 768), sin solapes, orden del enunciado respetado (comprobado).
Aviso de decodificación: ROM, EPROM, E/S y hueco quedan alineados, pero la RAM de 8K
no puede alinearse a su tamaño en este orden (un bloque de 8K solo empezaría limpio en
0000H o 2000H: la base 0000H choca con la ROM y la 2000H se comería el final del espacio
y no dejaría sitio para E/S-1 + hueco + E/S-2). Su CS es entonces la suma de las cuatro
combinaciones de A13A12A11 011, 100, 101 y 110, que cubren exactamente
1800H–37FFH: perfectamente asumible para el decodificador programable del apartado f),
aunque menos limpia que el reparto principal — que sí alinea todos los bloques a
potencias de 2, y es la razón de desarrollarlo como solución de referencia.
📚 Teoría: Tema 5, pág. 40 del PDF «Tema 5 SD-II_20230215.pdf» — señales de habilitación CE/EN de cada integrado.
d) Líneas de decodificación y porqué (0,25 p)
Un bloque de tamaño 2ⁿ consume internamente las n líneas bajas; la decodificación usa las que quedan por encima:
- ROM/RAM/EPROM (bloque): 4K → consumen A11…A0 → decodifican A13, A12 (4 combinaciones; se usan 00=ROM, 01=EPROM, 10=RAM; 11 queda para la zona de E/S).
- CI EPROM individuales: 1K → consumen A9…A0 → además se usa A11, A10 para elegir cuál de los 4 CI dentro del bloque EPROM.
- E/S: 256 → consumen A7…A0 → decodifican A13…A8 (el hueco de 768 no necesita CS: simplemente no se decodifica ninguna combinación 3100H–33FFH).
Justificación de la elección: los bloques grandes (4K) se colocan en las bases naturales de A13A12 y así solo se necesitan 2 líneas para ellos; la última combinación (11) se reserva a la zona fina de E/S+reserva, que es la única que requiere decodificación completa de A11…A8. Todo queda alineado en potencias de 2, lo que simplifica la decodificación y evita solapamientos.
📚 Teoría: Tema 5, pág. 34–35 del PDF «Tema 5 SD-II_20230215.pdf» — condiciones de habilitación y decodificación reducida. 📚 Teoría: Tema 1, pág. 3–5 del PDF «Tema 1 SD-II_20200206.pdf» — decodificador completo: n entradas y 2ⁿ salidas.
e) Diagrama lógico completo (1 p) — descripción detallada
Figura: diagrama lógico completo de la solución de ejemplo (mapa de los apartados b/c y decodificación de los apartados d/f).
Dibujar lo siguiente (todo conectado, con nombres de señal):
- CPU (bloque): bus de direcciones A13…A0 (14 líneas), bus de datos de 16 bits D15…D0, señales de control R/W̄.
- Partición del bus de direcciones: - A11…A0 → direcciones de las 2 ROM y de las 4 RAM. - A9…A0 → direcciones de las 4 EPROM (A11,A10 van a la decodificación). - A7…A0 → direcciones de los módulos E/S-1 y E/S-2.
- Bus de datos: ROM-0 → D7–D0, ROM-1 → D15–D8; cada EPROM → D15–D0; RAM-0 → D3–D0, RAM-1 → D7–D4, RAM-2 → D11–D8, RAM-3 → D15–D12; E/S ↔ D15…D0 (E/S usan 8 bits: D7–D0).
- Bloque decodificador (PLA/dispositivo programable o módulo VHDL del apartado f):
entradas A13…A8; salidas:
-
CS_ROM(BAJO) → al CS de las 2 ROM. -CS_EPROM0..3(BAJO) → al CS de cada EPROM. -CS_RAM(BAJO) → al CS de las 4 RAM. -CS_ES1(ALTO) → a CS1 y CS2 del módulo E/S-1. -CS_ES2(ALTO) → a CS1 y CS2 del módulo E/S-2. - Control de lectura/escritura: R/W̄ de la CPU → OE (y WE̅ en la RAM) de las memorias habilitadas; en E/S, las señales de lectura/escritura del bus de control con los strobes del módulo (dibujar el AND CS·read/write si el módulo lo pide).
- Todas las líneas sin usar (A15, A14 no existen; A9, A8 en ROM/RAM van directas; dejar claro qué línea va a dónde).
📚 Teoría: Tema 1, pág. 45–47 del PDF «Tema 1 SD-II_20200206.pdf» — matrices lógicas programables: PLA.
f) Módulo VHDL de decodificación para FPGA (0,75 p)
Analizado con GHDL 4.1.0 (--std=08 estricto — este módulo solo usa comparaciones de patrones, no
necesita STD_LOGIC_UNSIGNED) y verificado con un barrido exhaustivo de las 16.384 direcciones
(0000H–3FFFH) con las expectativas generadas por rangos desde la tabla del apartado b): 16.384
comprobaciones, 0 fallos, 0 solapes — en cada dirección activa exactamente una señal: ROM = 4.096
direcciones, cada EPROM 1.024 (4.096 en total), RAM = 4.096, E/S-1 = 256, E/S-2 = 256; en los huecos
3100H–33FFH y 3500H–3FFFH (3.584 direcciones) ninguna CS activa, y fuera de 3000H–30FFH y 3400H–34FFH
los dos when A = … de E/S mantienen '0'. Scripts: decodificador.vhd y tb_decodificador.vhd en
~/.hermes/cache/scratch/vhdl-jun26/:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity Decodificador is
port (
A : in std_logic_vector(13 downto 8); -- lineas altas de direccion
CS_ROM : out std_logic; -- activa a nivel BAJO
CS_EPROM : out std_logic_vector(3 downto 0); -- una por EPROM, BAJO
CS_RAM : out std_logic; -- activa a nivel BAJO
CS_ES1 : out std_logic; -- activa a nivel ALTO (CS1 y CS2)
CS_ES2 : out std_logic -- activa a nivel ALTO (CS1 y CS2)
);
end entity Decodificador;
architecture Behaviour of Decodificador is
begin
-- ROM: A13 A12 = 0 0 (0000H - 0FFFH)
CS_ROM <= '0' when A(13 downto 12) = "00" else '1';
-- EPROM: A13 A12 = 0 1 y A11 A10 elige el CI de 1K (1000H - 1FFFH)
with A(13 downto 10) select CS_EPROM <=
"1110" when "0100", -- EPROM0: 1000H - 13FFH
"1101" when "0101", -- EPROM1: 1400H - 17FFH
"1011" when "0110", -- EPROM2: 1800H - 1BFFH
"0111" when "0111", -- EPROM3: 1C00H - 1FFFH
"1111" when others;
-- RAM: A13 A12 = 1 0 (2000H - 2FFFH)
CS_RAM <= '0' when A(13 downto 12) = "10" else '1';
-- E/S-1: A13..A8 = 1 1 0 0 0 0 (3000H - 30FFH)
CS_ES1 <= '1' when A = "110000" else '0';
-- E/S-2: A13..A8 = 1 1 0 1 0 0 (3400H - 34FFH)
CS_ES2 <= '1' when A = "110100" else '0';
end architecture Behaviour;
📚 Teoría: Tema 1, pág. 33–34 del PDF «Tema 1 SD-II_20200206.pdf» — decodificador 3–8 en VHDL, con enable. 📚 Teoría: Tema 5, pág. 36–37 del PDF «Tema 5 SD-II_20230215.pdf» — VHDL de la decodificación del mapa de memoria. 📚 Teoría: Tema 1, pág. 23 del PDF «Tema 1 SD-II_20200206.pdf» — dispositivos programables: CPLD y FPGA.
Errores típicos — P1
- Olvidar la expansión de bits: poner 1 sola ROM 4K×8 (hacen falta 2) o 1 sola RAM 4K×4 (hacen falta 4). Es lo primero que se comprueba.
- Olvidar la expansión de palabras en EPROM: 4K/1K = 4 CI, no 1.
- Usar A14 y A15: no existen, 16K posiciones = 14 líneas.
- Tabla solo "por bloque" sin bajar al nivel de cada CI (la pregunta dice "cada circuito").
- Confundir la polaridad: memorias CS̅ (BAJO), E/S CS1/CS2 (ALTO).
- Hueco mal colocado que rompe la alineación de E/S-2 (768 = 3×256 encaja justo entre las dos zonas de 256).
- Solapar bloques u olvidar justificar por qué se eligen A13A12 para los bloques 4K.
- Dar por supuesto un tamaño fijo de EPROM o RAM sin justificar: el enunciado no lo da y hay rango admisible (RAM 4K u 8K; con RAM 4K, EPROM 1K–6K; con RAM 8K, EPROM 1K–2K). Si se cambia el reparto hay que recalibrar en consecuencia y de forma coherente direcciones, mapa, tablas y CS de todo el problema; cambiarlo a medias invalida el ejercicio.
Esquema-resumen de la metodología
- Extraer buses y espacio del enunciado — nº de posiciones y ancho de palabra fijan las líneas de dirección (16K×16 → A13–A0); todas las direcciones en hex de 4 dígitos y sin usar A14/A15, que no existen.
- Colocar primero los bloques de tamaño fijo — ROM 4K en 0000H y la zona de E/S (E/S-1 256, hueco 768 = 3×256, E/S-2 256) con bases alineadas en potencias de 2; lo fijo deja el hueco donde irán EPROM y RAM.
- Derivar el rango admisible de lo que el enunciado no fija — a las 11 008 posiciones libres se ajustan RAM (4K u 8K, múltiplos de sus CIs 4K×4) y EPROM (1K–6K con RAM 4K; 1K–2K con RAM 8K); se elige un reparto concreto y se justifica con la suma.
- Comprobar alineación y holgura — cada bloque de 2ⁿ con base múltiplo de su tamaño (uno desalineado obliga a una CS que es suma de varias combinaciones) y total de posiciones ≤ 16 384.
- Fijar qué líneas decodifican cada bloque — un bloque de 2ⁿ consume internamente las n líneas bajas y se selecciona con las de encima: bloques de 4K → A13A12; cada EPROM de 1K, además A11A10; E/S de 256 → A13…A8.
- Escribir las ecuaciones CS con la polaridad del enunciado — memorias CS̅ activas a nivel BAJO; E/S CS1 y CS2 activas a nivel ALTO y unidas a la misma salida de decodificación; los huecos libres simplemente no se decodifican.
- Montar cada bloque con los CIs disponibles — expansión de bits con CIs en paralelo aportando trozos del bus de datos (2 ROM 4K×8, 4 RAM 4K×4) y expansión de palabras en cascada ocupando sub-rangos (4 EPROM 1K×16); en paralelo comparten direcciones y CS.
- Dibujar el diagrama lógico completo — CPU, buses con nº de líneas, partición de direcciones por bloque, datos por CI, decodificador con todas las CS y R/W‾ (OE en todas las memorias, WE‾ solo en RAM).
- Trasladar la decodificación a VHDL y simularla — una expresión o
with ... selectpor CS sobre A13…A8; la simulación confirma que cada CS activa exactamente en su rango y que en los huecos no activa ninguna. - Barrer todo el espacio de direcciones (0000H–3FFFH) — en cada dirección debe activar una sola CS, o ninguna en los huecos: sin solapes y con las fronteras exactas de la tabla.
Idea transversal: el mapa solo vale si se alinea cada bloque de 2ⁿ sobre múltiplo de su tamaño y se comprueba barriendo todo el espacio de direcciones en busca de solapes y fronteras, no solo direcciones de ejemplo.
Problema 2 — Trampilla de tolva: ASM + VHDL (3,5 puntos)

Planteamiento. La trampilla es una máquina de estados con dos posiciones límite (fijadas por la figura: Z = extendido = cerrada, Y = recogido = abierta; la trampilla se mete en el cuello de la tolva, que está a la derecha del cilindro), dos pulsadores (A abre, C cierra) y un cilindro (I abre, D cierra). Las esperas de 5, 6 y 3 segundos empiezan al SOLTAR el pulsador, y los finales de carrera detienen el motor automáticamente. Los LEDs indican posición: rojo = totalmente cerrada, verde = totalmente abierta.
Datos que fijan el enunciado y la figura. En la figura el cilindro está a la IZQUIERDA y el vástago/trampilla sale hacia la DERECHA metiéndose en el cuello de la tolva, con el dibujo en posición CERRADA: por eso Z (todo extendido) = CERRADA e Y (todo recogido) = ABIERTA. I abre y D cierran: conservan su papel, NO se permutan (la geometría invierte el significado de los finales de carrera, no el del cilindro). V = led VERDE (abierta) y R = led ROJO (cerrada) según el panel de la figura. Los pulsadores A y C nunca se accionan a la vez, y los finales de carrera Y y Z no pueden estar activos simultáneamente (lo fija el enunciado).
a) Cálculos previos con reloj de 25 MHz (0,25 p)
- Periodo del reloj: T = 1/25 MHz = 40 ns.
- Pulsos necesarios:
- 5 s → 5 × 25 000 000 = 125 000 000 pulsos
- 6 s → 150 000 000 pulsos
- 3 s → 75 000 000 pulsos
- Descomposición (pre-escala decimal + contador binario): como 125 000 000 = 10⁶ × 125, 150 000 000 = 10⁶ × 150 y 75 000 000 = 10⁶ × 75, se usa una pre-escala compartida MOD-1 000 000 (25 MHz → 25 Hz; un "tick" cada 40 ms): MOD-10 en cascada (décadas) → 2,5 MHz; 5 décadas más → 25 Hz. En binario, MOD-10⁶ exige 20 bits (2²⁰ = 1 048 576 ≥ 10⁶).
- Contadores finales sobre el tick de 25 Hz (periodo 40 ms):
- CTR5: MOD-125 → 125 × 40 ms = 5,000 s ✔ (7 bits, 2⁷ = 128)
- CTR6: MOD-150 → 150 × 40 ms = 6,000 s ✔ (8 bits, 2⁸ = 256)
- CTR3: MOD-75 → 75 × 40 ms = 3,000 s ✔ (7 bits, 2⁷ = 128)
- Cada contador se habilita (
EN) solo en su estado de espera y con el pulsador ya soltado, y genera su banderaFIN(se autorreseta al salir del estado).
📚 Teoría: Tema 2, pág. 55 del PDF «Tema 2 SD-II_20200317.pdf» — contador: secuencia predefinida de estados. 📚 Teoría: Tema 2, pág. 57–58 del PDF «Tema 2 SD-II_20200317.pdf» — asociación de contadores: módulo mayor. 📚 Teoría: Tema 2, pág. 59 del PDF «Tema 2 SD-II_20200317.pdf» — división de frecuencia: pre-escala del reloj.
b) Diagrama ASM y bloques obtenidos (2 p)
Bloques ASM (uno por estado; entre corchetes las salidas activas del estado; ninguna transición = permanecer en el estado):
| # | Estado (bloque ASM) | Salidas | Decisiones → siguiente estado |
|---|---|---|---|
| 1 | CIERRE_INICIAL |
D=1 | Z=1 → CERRADA |
| 2 | CERRADA |
R=1 (=Z) | A=1 → ESPERA_A_5S |
| 3 | ESPERA_A_5S |
(R=Z) | A=1: espera; A=0: CTR5 cuenta; FIN_CTR5 → ABRIR |
| 4 | ABRIR |
I=1 | Y=1 → ABIERTA; C=1 → ESPERA_C_6S |
| 5 | ESPERA_C_6S |
(V=Y) | C=1: espera; C=0: CTR6 cuenta; FIN_CTR6 → CERRAR |
| 6 | ABIERTA |
V=1 (=Y) | C=1 → ESPERA_C_5S |
| 7 | ESPERA_C_5S |
(V=Y) | C=1: espera; C=0: CTR5 cuenta; FIN_CTR5 → CERRAR |
| 8 | CERRAR |
D=1 | Z=1 → CERRADA; A=1 → ESPERA_A_3S |
| 9 | ESPERA_A_3S |
— | A=1: espera; A=0: CTR3 cuenta; FIN_CTR3 → ABRIR |
Grafo de transiciones (en el diagrama ASM cada fila es un bloque con su caja de estado, caja condicional de salidas y cajas de decisión):
Claves del planteamiento (puntos del enunciado): - "5/6/3 segundos DESPUÉS DE SOLTAR": mientras el pulsador sigue a 1 el contador no cuenta (ramilla A=0 / C=0 antes de la decisión FIN). - "si alcanza alguna posición límite se detendrá": en ABRIR, Y=1 → ABIERTA (I deja de activarse); en CERRAR, Z=1 → CERRADA (D se apaga). - Al conectar: estado CIERRE_INICIAL con D=1 hasta Z (cerrar si no lo estaba; la figura fija la regla de oro: límite derecho = Z = todo extendido = CERRADA, porque la trampilla tapa el cuello de la tolva a la derecha del cilindro). - Los dos estados de 5 s son distintos bloques (origen C desde cerrada ≠ origen A desde cerrada en reposo) aunque compartan contador: hay que dibujar los 9 bloques. - Durante las esperas el cilindro está parado (ninguna salida I/D).
📚 Teoría: Tema 3, pág. 15–19 del PDF «Tema 3 SD-II_20200413.pdf» — diagramas ASM: estado, salidas, decisiones. 📚 Teoría: Tema 3, pág. 22 del PDF «Tema 3 SD-II_20200413.pdf» — diagrama de estados y ASM equivalentes.
c) Módulo VHDL respetando los nombres ASM (1,25 p)
En el VHDL las comparaciones de los límites y las consignas de los LEDs (R←Z, V←Y)
siguen la figura del enunciado (Z = cerrada, Y = abierta): los nombres de estados, la estructura y los contadores son los del ASM, escritos con el pattern de clase de Tema 3 (págs. 30–32): un solo proceso con wait until clk='1', reset síncrono y las salidas dentro de cada rama. Analizado con GHDL 4.1.0 (--std=08 -fsynopsys) y verificado con un testbench que exploita la retícula determinista de la pre-escala (arranca en 0 con el reset y envuelve cada PRE+1 flancos) y comprueba, flanco a flanco y con asserts de exactitud: cierre inicial con D hasta Z; que con el pulsador mantenido el contador NO avanza (mantenido más allá de las 125/150/75 envolturas necesarias); que tras soltar, la salida se produce exactamente en la envoltura 125ª (5 s), 150ª (6 s) y 75ª (3 s) respectivamente; paradas en finales de carrera con el LED correcto (R solo en CERRADA, V solo en ABIERTA, y R=Z / V=Y durante las esperas); y reset a mitad de cuenta que limpia y rearma la retícula desde cero. Escala de simulación PRE=9: TEST PASSED (257.151 ns); segunda escala PRE=49: TEST PASSED (1.217.151 ns) — asserts calculados sobre las constantes, linealidad exacta. Extrapolado a escala real (PRE=999.999): las pausas son 125·10⁶, 150·10⁶ y 75·10⁶ flancos de 25 MHz = 5,000 / 6,000 / 3,000 s justos (más la latencia de 1 flanco de la rama de salidas). Scripts: control_trampilla.vhd y tb_control_trampilla.vhd en ~/.hermes/cache/scratch/vhdl-jun26/.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL; -- suma/comparaciones sobre vectores (estilo de clase)
entity Control_Trampilla is
generic (
G_PRE_MAX : integer := 999_999; -- pre-escala MOD-1e6: 25 MHz -> tick cada 40 ms
G_T5 : integer := 125; -- MOD-125 de ticks = 5,000 s (CTR5)
G_T6 : integer := 150; -- MOD-150 de ticks = 6,000 s (CTR6)
G_T3 : integer := 75 -- MOD-75 de ticks = 3,000 s (CTR3)
);
port (
clk, reset : in std_logic; -- reloj de 25 MHz; reset sincrono (Tema 3 p.30)
A, C, Y, Z : in std_logic; -- pulsadores y finales de carrera
V, R, I, D : out std_logic -- led verde / led rojo / cilindro abre / cilindro cierra
);
end entity Control_Trampilla;
architecture ASM of Control_Trampilla is
-- nombres de estado = nombres de los bloques del diagrama ASM
type mis_estados is (CIERRE_INICIAL, CERRADA, ESPERA_A_5S, ABRIR,
ESPERA_C_6S, ABIERTA, ESPERA_C_5S, CERRAR, ESPERA_A_3S);
signal estado : mis_estados;
signal pre : std_logic_vector(19 downto 0); -- pre-escala MOD-1e6 compartida
signal cnt5 : std_logic_vector(7 downto 0); -- llega a 149: 8 bits (MOD-150 es el mayor)
signal cnt6 : std_logic_vector(7 downto 0);
signal cnt3 : std_logic_vector(6 downto 0); -- llega a 74
begin
process
begin
wait until clk = '1';
if (reset = '1') then -- reset sincrono: arranque = cierre inicial
estado <= CIERRE_INICIAL;
pre <= (others => '0');
cnt5 <= (others => '0'); cnt6 <= (others => '0'); cnt3 <= (others => '0');
V <= '0'; R <= '0'; I <= '0'; D <= '0';
else
if pre = G_PRE_MAX then pre <= (others => '0');
else pre <= pre + 1; -- pre-escala siempre cuenta: tick cada 40 ms
end if;
case estado is
when CIERRE_INICIAL => -- al conectar, cerrar si no lo estaba
D <= '1'; V <= '0'; R <= '0'; I <= '0';
if Z = '1' then estado <= CERRADA; end if;
when CERRADA => -- posicion limite cerrada (Z extendida)
R <= '1'; V <= '0'; I <= '0'; D <= '0';
cnt5 <= (others => '0');
if A = '1' then estado <= ESPERA_A_5S; end if;
when ESPERA_A_5S => -- 5 s DESPUES DE SOLTAR A
R <= Z; V <= '0'; I <= '0'; D <= '0';
if A = '1' then
cnt5 <= (others => '0'); -- boton aun pulsado: no cuenta
elsif pre = G_PRE_MAX then
if cnt5 = G_T5 - 1 then
cnt5 <= (others => '0'); -- salida limpia
estado <= ABRIR;
else cnt5 <= cnt5 + 1; end if;
end if;
when ABRIR => -- moviendose a la izquierda (abrir)
I <= '1'; V <= '0'; R <= '0'; D <= '0';
cnt5 <= (others => '0'); cnt6 <= (others => '0');
if Y = '1' then estado <= ABIERTA;
elsif C = '1' then estado <= ESPERA_C_6S; end if;
when ESPERA_C_6S => -- 6 s DESPUES DE SOLTAR C (interrupcion de apertura)
V <= Y; R <= '0'; I <= '0'; D <= '0';
if C = '1' then
cnt6 <= (others => '0');
elsif pre = G_PRE_MAX then
if cnt6 = G_T6 - 1 then
cnt6 <= (others => '0');
estado <= CERRAR;
else cnt6 <= cnt6 + 1; end if;
end if;
when ABIERTA => -- posicion limite abierta (Y recogida)
V <= '1'; R <= '0'; I <= '0'; D <= '0';
cnt5 <= (others => '0');
if C = '1' then estado <= ESPERA_C_5S; end if;
when ESPERA_C_5S => -- 5 s DESPUES DE SOLTAR C (desde ABIERTA)
V <= Y; R <= '0'; I <= '0'; D <= '0';
if C = '1' then
cnt5 <= (others => '0');
elsif pre = G_PRE_MAX then
if cnt5 = G_T5 - 1 then
cnt5 <= (others => '0');
estado <= CERRAR;
else cnt5 <= cnt5 + 1; end if;
end if;
when CERRAR => -- moviendose a la derecha (cerrar)
D <= '1'; V <= '0'; R <= '0'; I <= '0';
cnt3 <= (others => '0');
if Z = '1' then estado <= CERRADA;
elsif A = '1' then estado <= ESPERA_A_3S; end if;
when ESPERA_A_3S => -- 3 s DESPUES DE SOLTAR A (interrupcion de cierre)
V <= '0'; R <= '0'; I <= '0'; D <= '0';
if A = '1' then
cnt3 <= (others => '0');
elsif pre = G_PRE_MAX then
if cnt3 = G_T3 - 1 then
cnt3 <= (others => '0');
estado <= ABRIR;
else cnt3 <= cnt3 + 1; end if;
end if;
when others => estado <= CIERRE_INICIAL;
end case;
end if;
end process;
end architecture ASM;
Notas para el examen: la «habilitación» del contador es la propia rama del estado (el contador solo
cuenta dentro de su estado de espera) y además la ramilla A = '0' / C = '0': con el botón
pulsado la rama pone el contador a cero en cada flanco, que es la traducción directa de «empieza al
SOLTAR». El contador se escribe en std_logic_vector con la suma y la comparación de estilo de clase
(STD_LOGIC_UNSIGNED); el generic es solo para simular — en el examen se comparan las constantes
reales 999_999, 124, 149 y 74. Los tres contadores comparten la pre-escala, que cuenta libre:
la cuenta de cada pausa se mide en ticks desde la ramilla de soltado, y cada estado de espera limpia
su contador mientras el botón sigue pulsado.
📚 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 (antirrebote). 📚 Teoría: Tema 2, pág. 14–16 del PDF «Tema 2 SD-II_20200317.pdf» — biestables en VHDL: memoria implícita. 📚 Teoría: Tema 2, pág. 56 del PDF «Tema 2 SD-II_20200317.pdf» — contador síncrono de 4 bits en VHDL.
Errores típicos — P2
- Contar los segundos desde que se pulsa en lugar de desde que se suelta: pierde la ramilla A=0/C=0 antes de FIN y contradice el enunciado (es la trampa del examen).
- Olvidar los estados de espera previos a abrir/cerrar EN MOVIMIENTO (6 s y 3 s) o fusionar los dos estados de 5 s en uno solo.
- No detener el cilindro al alcanzar Z o Y (falta la decisión de límite).
- Confundir qué final de carrera significa abierta y cuál cerrada: la figura lo fija (cilindro a la izquierda, vástago entrando en el cuello de la tolva a la derecha, dibujo en posición cerrada) → Z = todo extendido = CERRADA, Y = todo recogido = ABIERTA. Los textos «recogido/extendido» del enunciado no bastan solos: hay que mirar la geometría de la trampilla.
- Querer permutar también I↔D al detectar que Y y Z están al revés de lo intuitivo: en ESTA figura I abre y D cierran; solo se intercambian las señales de los finales de carrera. Permutar I↔D haría que el cierre inicial condujera el cilindro con I (izquierda), que es precisamente abrir — contradice el propio estado CIERRE_INICIAL.
- Olvidar el cierre inicial al conectar (estado CIERRE_INICIAL).
- LEDs mal: rojo solo en CERRADA, verde solo en ABIERTA (no durante el movimiento).
- VHDL con nombres de estado inventados (S0, S1…): el enunciado exige que coincidan con los bloques ASM → se pierden puntos aunque el código funcione.
- Escribir dos procesos (secuencial + combinacional) con
siguiente/valores por defecto: el estilo de Tema 3 es un solo proceso conwait until clk='1'y las salidas escritas dentro de cada rama delcase(poniendo'0'en las salidas ajenas a ese estado); y falta casi siempre el reset síncrono en puertos, que en este diseño no es decorativo: el arranque conCIERRE_INICIALse apoya en él. - Olvidar la salida limpia: al cumplir el límite hay que poner el contador a cero y
cambiar de estado en la misma rama, y limpiar la cuenta al ENTRAR en cada estado
temporizado (ramas de
ABRIR/CERRAR/CERRADA/ABIERTA) — si no, la cuenta vieja acorta la pausa siguiente. - Cuenta mal los pulsos: 5 s ≠ 5 × 25 000; 5 s = 125 000 000.
Esquema-resumen de la metodología
- Leer la figura antes que nada y fijar la semántica física — la geometría manda: con el vástago entrando en el cuello de la tolva a la derecha, Z (todo extendido) = CERRADA e Y (todo recogido) = ABIERTA; I abre y D cierran sin permutarse (solo se intercambian los finales de carrera) y V/R son los LEDs de abierta/cerrada.
- Enumerar entradas y salidas de la unidad de control — entradas A, C (pulsadores) e Y, Z (finales de carrera); salidas I, D (cilindro) y V, R (LEDs); se anotan las garantías del enunciado (A y C nunca a la vez, Y y Z nunca simultáneos), que luego simplifican las decisiones.
- Traducir los segundos a pulsos de reloj con pre-escala — T = 40 ns; 5/6/3 s son 125/150/75 millones de pulsos; se descompone 10⁶ × (125/150/75): pre-escala MOD-10⁶ compartida (25 MHz → 25 Hz, tick de 40 ms) más contadores MOD-125/150/75 sobre el tick.
- Diseñar la ASM con un bloque por estado y nombres propios — caja de estado con sus salidas activas, decisiones encadenadas y permanencia cuando no cabe transición; aquí salen 9 estados, incluidos los dos bloques de 5 s, distintos aunque compartan contador.
- Volcar en el grafo las trampas del enunciado — el contador se habilita solo al SOLTAR el pulsador (ramilla A=0/C=0 antes de la decisión FIN); alcanzar el límite detiene el motor (Y=1→ABIERTA, Z=1→CERRADA); al conectar hay CIERRE_INICIAL con D hasta Z; los LEDs solo indican posición límite.
- Escribir el VHDL 1:1 con los nombres de la ASM —
type mis_estadoscon los nombres de los bloques; un solo proceso conwait until clk='1'másif reset='1'(síncrono: dejaCIERRE_INICIAL, cuentas a cero y salidas en reposo); pre-escala que cuenta siempre, contadores enstd_logic_vectorcon la suma deSTD_LOGIC_UNSIGNED, y las salidas escritas dentro de cada rama delcase(when others =>incluido). - Verificar la cuenta FIN de cada contador — MOD-N sobre el tick: N × 40 ms debe dar exactamente 5,000/6,000/3,000 s (y 5 s = 125 000 000 pulsos de 25 MHz, no 5 × 25 000).
- Simular la secuencia completa con testbench — cierre inicial, esperas de 5/6/3 s tras soltar el pulsador, paradas en finales de carrera y LEDs correctos: cada situación del enunciado debe verse reflejada en la simulación.
Idea transversal: la semántica la fija la geometría de la figura y ningún tiempo del enunciado se cuenta a ojo: todo se traduce a pulsos con pre-escala + contador; y ASM y VHDL son el mismo diseño dicho dos veces, con los mismos nombres bloque a bloque.
Problema 3 — Microcontrolador PicoBlaze (3 puntos)

Planteamiento. Un PicoBlaze (núcleo KCPSM) lee 4 puertos de entrada (14, 16, 29,
30) y los guarda en su RAM scratchpad en la posición cuyo número es el mismo del
puerto (H'0E', H'10', H'1D', H'1E'; lectura literal de «guardará estos valores en las
mismas posiciones de la RAM»). La RAM se declara suficiente hasta H'1E'. Realiza tres
operaciones con los datos recuperados, sacando resultados por los puertos de salida
127, 220 y 223.
El programa es un bucle infinito a)→d); una interrupción (vector en la última posición
de la ROM, 3FFH: JUMP ISR; el hardware ya apila el PC, preserva Z/C, enmascara y fuerza
el fetch del vector) borra las 3 salidas y toda la RAM declarada (H'00'–H'1E') y
reinicia el programa. La ROM de programa es EXTERNA al módulo KCPSM y debe aparecer en el diagrama.
Decisiones de diseño del planteamiento. La posición RAM de cada dato es el mismo
número del puerto (lectura literal de «las mismas posiciones de la RAM»; EQU simbólicos
H"0E"/H"10"/H"1D"/H"1E"), y la RAM se declara suficiente hasta H'1E'. En el vector de
interrupción (3FFH) basta JUMP ISR: el hardware ya hace él solo el CALL. La ISR
borra las 3 salidas y toda la RAM declarada, H'00'–H'1E' (limpiar solo las 4
posiciones usadas es interpretación con riesgo de perder puntos), no lleva EINT
dentro y termina con JUMP INICIO («volverá a empezar desde el principio»). El
desarrollo y la justificación de cada decisión, en el apartado b).
Nombres simbólicos (EQU) usados: puertos y direcciones RAM.
P_IN14 EQU H"0E" ; puerto entrada 14 (decimal)
P_IN16 EQU H"10" ; puerto entrada 16
P_IN29 EQU H"1D" ; puerto entrada 29
P_IN30 EQU H"1E" ; puerto entrada 30
P_OUT127 EQU H"7F" ; puerto salida 127
P_OUT220 EQU H"DC" ; puerto salida 220
P_OUT223 EQU H"DF" ; puerto salida 223
R14 EQU H"0E" ; RAM scratchpad: la direccion = nº del puerto (14 = H'0E')
R16 EQU H"10" ; dato del puerto 16 -> H'10'
R29 EQU H"1D" ; dato del puerto 29 -> H'1D'
R30 EQU H"1E" ; dato del puerto 30 -> H'1E'
a) Diagrama lógico detallado incluyendo la memoria de programa (1 p)
Figura: diagrama lógico del PicoBlaze con su memoria de programa y la lógica de puertos (apartado a).
Dibujar y conectar (descripción textual de lo que debe aparecer):
- Bloque KCPSM (firmcore PicoBlaze, embebido en la FPGA) con sus puertos:
clk,reset,interrupt_port(entrada int),input_port(7:0),output_port(7:0),program_port_addr(9:0),program_port_instruction(17:0), strobesread_strobe/write_strobe(en KCPSM3 tambiénoutput_port_strobe(7:0)), y las líneas internas deport_id(8 bits). - Memoria de programa: ROM 1024 × 18 (block/distributed RAM) — NO está dentro del
núcleo: direcciones 000H–3FEH = instrucciones ensambladoras; dirección 3FFH =
JUMP ISR(vector de interrupción: al producirla, el hardware apila el PC, preserva Z/C, enmascara y fuerza el fetch de esa dirección por sí solo).program_port_addrsale del núcleo a la ROM;program_port_instructionvuelve a él. Dibujarla SIEMPRE (vale 1 punto). - Decodificación de puertos (lógica FPGA fuera del núcleo):
- Lectura: comparadores de
port_idcon H"0E", H"10", H"1D", H"1E" que seleccionan (multiplexor) qué dispositivo de entrada conduceinput_port, junto conread_strobe. - Escritura: comparadores con H"7F", H"DC", H"DF" que, AND conwrite_strobe, habilitan el registro/latch de salida de cada puerto desdeoutput_port. - Dispositivos externos: 4 entradas (sensores/interruptores a 8 bits) a las
entradas del multiplexor; 3 registros de salida de 8 bits hacia sus periféricos;
la línea
int(pulso ≥ 2 clk) alinterrupt_port. - Reloj y reset conectados. Ningún bus de datos externo con direcciones: los "bus de
E/S" del PicoBlaze son el
input_port/output_portde 8 bits +port_id.
📚 Teoría: Tema 4, pág. 11–12 del PDF «Tema 4 SD-II_20220512.pdf» — arquitectura PicoBlaze: bloques y pila. 📚 Teoría: Tema 4, pág. 31–34 del PDF «Tema 4 SD-II_20220512.pdf» — puertos: PORT_ID, strobes y conexión. 📚 Teoría: Tema 4, pág. 45 y 49 del PDF «Tema 4 SD-II_20220512.pdf» — ROM de programa externa: bloque RAM 1Kx18. 📚 Teoría: Tema 1, pág. 12–13 del PDF «Tema 1 SD-II_20200206.pdf» — multiplexores: selectores de datos.
b) Programa ensamblador comentado (2 p)
El enunciado exige el programa «debidamente comentado»: cada región lleva un
encabezado en comentario que explica su qué y su porqué, más alguna línea suelta
solo donde merezca la pena (valores mágicos como H"1E" o H"32", y la
aritmética con carry). Un comentario en cada línea no es legible y no puntúa más.
Directrices: ORG para la
posición de la ROM; el vector de interrupción en la última posición (3FFH). La
nomenclatura sigue la tabla impresa del examen: IN/OUT (no INPUT/OUTPUT),
formas constantes sin paréntesis (IN s0,H"0E", STORE s0,R14) y paréntesis solo
en la forma indirecta (STORE s0,(s1)).
;==================== vector de interrupcion =====================
; La ROM de programa acaba siempre en su ultima posicion (3FFH). Al producirse
; la interrupcion el HARDWARE hace el CALL al vector el solo: apila el PC,
; preserva Z/C y enmascara las interrupciones. Aqui solo hace falta el salto:
; JUMP ISR es lo que "aprovecha" el mecanismo de interrupcion del PicoBlaze.
ORG H"3FF"
JUMP ISR
;==================== programa principal (cabecera INICIO) ========
; Bucle infinito a) -> b) -> c) -> d) -> a) ... Cada vuelta pasa por INICIO,
; que prepara s7 = 0 (el registro "cero" con el que luego se borran las
; salidas) y re-arma la interrupcion con EINT: tras ser atendida queda
; enmascarada, y la tabla impresa no tiene DINT.
ORG H"000"
INICIO: LOAD s7, H"00" ; s7 = 0 durante toda la ejecucion
COMP s7, H"01" ; defensivo: deja CY=0 (ver la nota de SUMA5)
EINT
; ---- a) leer los 4 puertos y guardarlos en la RAM scratchpad ----
; El enunciado dice literalmente que "guardara estos valores en las mismas
; posiciones de la RAM": la posicion de cada dato es el MISMO numero del puerto
; (puerto 14 -> H'0E', 16 -> H'10', 29 -> H'1D', 30 -> H'1E'), y asi queda
; reutilizable en los apartados b), c) y d).
IN s0, P_IN14
STORE s0, R14
IN s1, P_IN16
STORE s1, R16
IN s2, P_IN29
STORE s2, R29
IN s3, P_IN30
STORE s3, R30
; ---- b) puerto 14: si vale 30 o 40, sumar 5 y sacarlo por 127 ----
; Se compara el dato guardado en a) con los dos unicos valores que admite el
; enunciado: H"1E" = 30 y H"28" = 40 (decimales). Si coincide, se suma 5; si
; no, por el puerto de salida 127 (H"7F") debe salir un 1.
FETCH s4, R14
COMP s4, H"1E" ; ¿vale 30 decimal?
JUMP Z, SUMA5 ; si -> sumar 5
COMP s4, H"28" ; ¿vale 40 decimal?
JUMP Z, SUMA5 ; si -> sumar 5
LOAD s4, H"01" ; no es 30 ni 40: preparo el valor 1
OUT s4, P_OUT127
JUMP PASO_C
SUMA5: COMP s7, H"01" ; redundante con esta tabla porque ADD no usa la
; CY de entrada; se deja por seguridad
ADD s4, H"05" ; sumo 5 al dato del puerto 14
OUT s4, P_OUT127
; ---- c) sumar RAM(puerto 16) + RAM(puerto 29) -> puerto 220 ----
; Suma de dos registros: el resultado de 8 bits queda en s5 y, si la suma real
; pasa de 255, el acarreo sale por CY. Con acarreo hay que restar 50 (H"32")
; al resultado; sin acarreo la salida 220 (H"DC") se pone a 0.
PASO_C: COMP s7, H"01"
FETCH s5, R16
FETCH s6, R29
ADD s5, s6 ; ADD ignora la CY entrante y produce CY=1 si la
; suma se pasa de 255 (acarreo hacia fuera)
JUMP NC, CERO_220 ; CY=0: no hubo acarreo, la suma cupo en 8 bits
SUB s5, H"32" ; acarreo: p.ej. 150+120=270 deja s5=0EH (que es
; 270-256) y CY=1. SUB resta sin mirar esa CY:
; 0EH-32H = -36 = DCH en 8 bits (el prestamo
; devuelve los 256 del carry), o sea (270-50)
; mod 256 = 220. Por eso el byte es exacto
OUT s5, P_OUT220
JUMP PASO_D
CERO_220: ; rama sin acarreo
OUT s7, P_OUT220 ; saca el registro "cero"
; ---- d) puerto 30: MSB=1 -> todo unos en 223; MSB=0 -> +10 ----
; Se prueba el bit 7 con la mascara H"80": TEST deja Z=1 cuando el bit probado
; es 0 (al reves de lo que parece). Con MSB=1 el puerto 223 (H"DF") se pone a
; H"FF", todas sus lineas a 1; con MSB=0 se suma 10.
PASO_D: FETCH s4, R30
TEST s4, H"80" ; solo afecta a Z: Z=1 si el bit 7 era 0
JUMP Z, MAS10
LOAD s4, H"FF" ; MSB=1: pongo a uno TODAS las salidas del puerto
OUT s4, P_OUT223
JUMP INICIO
MAS10: COMP s7, H"01"
ADD s4, H"0A" ; sumo 10 (H"0A") al valor del puerto 30
OUT s4, P_OUT223
JUMP INICIO ; cierre del bucle infinito (a -> d -> a ...)
;==================== rutina de interrupcion (ISR) ================
; El hardware entra aqui al atender la interrupcion (ya paso por el vector). El
; enunciado exige borrar las 3 salidas y TODA la RAM: la RAM DECLARADA llega
; hasta H'1E' (la mayor direccion usada, la del puerto 30; el nucleo KCPSM6
; trae mas posiciones de serie) -> "toda la RAM" = la RAM declarada,
; H'00'-H'1E'. La RAM no se recorre con constantes -> registro indice s1 +
; forma indirecta STORE s0,(s1).
; Destruir el s1 del programa principal es inocuo: tras la ISR hay reinicio.
ISR: LOAD s0, H"00" ; s0 = 0, valor de borrado (salidas y RAM)
OUT s0, P_OUT127
OUT s0, P_OUT220
OUT s0, P_OUT223
LOAD s1, H"00" ; indice de recorrido de la RAM
LIMPIA: STORE s0, (s1) ; borro la posicion RAM apuntada por s1 (indirecto)
ADD s1, H"01" ; siguiente posicion
COMP s1, H"1F" ; tope H"1F" = 31: se limpian H'00'-H'1E' (la RAM
; declarada); COMP deja CY=0 solo cuando s1 >= H'1F'
JUMP NC, INICIO ; RAM entera limpia -> reinicio ("volvera al principio")
JUMP LIMPIA ; mientras s1 < H'1F', sigo borrando
Nota sobre el final de la ISR (JUMP INICIO, explicar en el examen): lo canónico
sería cerrar la ISR con RETI, pero RETI reanuda el programa principal a mitad del
bucle (en el punto interrumpido) y el enunciado obliga a volver desde el principio:
se acaba con JUMP INICIO. La entrada que el hardware apiló al producirse la
interrupción (el retorno de su CALL implícito al vector 3FFH) queda sin desapilar,
pero es inocua: la pila hardware del PicoBlaze es circular de 3 niveles y el
programa nunca usa RETURN. El re-arme de interrupciones lo hace el EINT de INICIO
en cada vuelta del bucle: tras ser atendida, la interrupción queda enmascarada (solo
EINT/RETI la re-habilitan) y dentro de la ISR está prohibido poner EINT —el
re-arme pertenece a INICIO—. Sin ese EINT en INICIO el sistema solo podría
interrumpirse una vez. (La tabla impresa no tiene DINT: solo EINT/RETI.)
Ejemplo comprobado a mano (entradas: P14=40, P16=150, P29=120, P30=200):
- a) RAM: [0E]=28H, [10]=96H, [1D]=78H, [1E]=C8H (cada dato, en la dirección de
número igual al de su puerto).
- b) 40 = H'28' → SUMA5: 40+5 = 45 → puerto 127 = 45 (2DH).
- c) 150+120 = 270 = 1_0E(8)… en 8 bits: ADD deja s5=0EH y produce CY=1 (la CY
solo flaggea el acarreo; SUB no la usa). 0EH − 32H = −36 = DCH (220, módulo
256; el préstamo es normal en 8 bits: 270 − 50 = 220) → puerto 220 = 220.
- d) 200 = C8H, bit 7 = 1 → puerto 223 = FFH (255).
- Sin acarreo (P16=100, P29=120 → 220 < 256): puerto 220 = 0.
- Interrupción a mitad de iteración → tras la ISR: puertos 127/220/223 = 0, toda la
RAM declarada (H'00'–H'1E') a 0, y el programa reinicia en INICIO con EINT
re-armado (comprobado con un emulador KCPSM).
📚 Teoría: Tema 4, pág. 27–30 del PDF «Tema 4 SD-II_20220512.pdf» — flags ZERO/CARRY: TEST, COMP, JUMP, CALL. 📚 Teoría: Tema 4, pág. 40–42 del PDF «Tema 4 SD-II_20220512.pdf» — scratchpad RAM: STORE/FETCH e indirecto. 📚 Teoría: Tema 4, pág. 37–39 del PDF «Tema 4 SD-II_20220512.pdf» — interrupciones: EINT, vector, ISR.
Errores típicos — P3
- No dibujar la ROM de programa (1024×18) fuera del núcleo KCPSM, o no poner el
vector (con
JUMP ISR) en la dirección 3FFH. Vale 1 punto entero. - Olvidar
EINT(tras el reset las interrupciones están desactivadas; y tras ser atendida queda enmascarada hasta el siguienteEINT— por esoINICIOlo repite). La tabla impresa no tieneDINT: soloEINTyRETI. - Usar
INPUT/OUTPUT(mnemónicos de ensambladores reales tipo KCPSM3): la tabla impresa del examen no los contiene, sonIN/OUTcon forma constante sin paréntesis (IN sX,kk,OUT sX,kk) y paréntesis solo para(sY). Seguir SIEMPRE la tabla impresa, aunque el ensamblador del PC admita otros alias. - Enviar a un puerto un registro con basura: para mandar '0' o '1' hay que cargar el
valor (
LOAD s4,H"01") o asegurars7=0. - Atribuir a
ADD/SUBla semántica deADDC/SUBC: en la tabla impresa del examenADD/SUBno toman la CY de entrada (solo la producen: carry-out / borrow); las variantes que la usan se escribenADDC/SUBC. LosCOMP s7,H"01"antes de las sumas del programa se dejan como comprobación defensiva inocua (redundante con esta tabla). Y restar 50 tras unADDcon acarreo da exacto por aritmética módulo 256 (el préstamo delSUBdevuelve los 256 del carry), no por la CY. TEST s4,H"80"pone Z=1 cuando el bit probado es 0: al revés de lo que parece; elJUMPdebe elegirse con ese criterio.- Guardar/recuperar con direcciones RAM "a dedo" en vez de EQU simbólicos, o mezclar
las formas: la tabla imprime
STORE sX, kk/FETCH sX, kk(directo: constante SIN paréntesis) ySTORE sX, (sY)/FETCH sX, (sY)(indirecto: SOLO ahí con paréntesis).STORE s0,(R14)con paréntesis sobre una constante EQU se desvía de la forma literal impresa. - OLVIDAR la ISR: borrar solo puertos sin borrar RAM (o al revés), o limpiar solo las
4 posiciones usadas: el enunciado dice "toda la RAM" → borrar la RAM declarada,
H'00'–H'1E' (bucle
STORE s0,(s1)+ADD s1,H"01"+COMP s1,H"1F"+JUMP NC). Limpiar solo una parte tiene riesgo real de pérdida de puntos. - Poner
CALL ISRen el vector (redundante: el hardware ya hace elCALLal vector —apila el PC, preserva Z/C y enmascara—; bastaJUMP ISR) o terminar la ISR conRETIcuando el enunciado pide reinicio desde el principio. - Programa apenas comentado: "debidamente comentado" vale 2 puntos. El mínimo legible son los encabezados de región (vector, cabecera, a-d, ISR) explicando qué y porqué, más comentarios sueltos donde aportan; un comentario por línea no es necesario.
- Olvidar el bucle infinito
JUMP INICIOtras el apartado d).
Esquema-resumen de la metodología
- Asignar EQU a puertos y direcciones RAM antes de programar — puertos decimales a hex (14→H"0E" … 30→H"1E"; 127→H"7F"); el enunciado fija que la dirección RAM de cada dato es el mismo número de su puerto, y la mayor de esas direcciones (H'1E') declara la RAM suficiente.
- Dibujar el diagrama con la ROM de programa fuera del núcleo — ROM 1024×18 con el vector en la última posición 3FFH (
JUMP ISR); decodificación de puertos fuera del núcleo: comparadores deport_idconread_strobey MUX para las lecturas; comparadores + AND conwrite_strobe+ latches de 8 bits para las escrituras;int(pulso ≥ 2 clk), clk y reset. - Escribir el programa por regiones con encabezado comentado — vector, cabecera INICIO, apartados a)-d) e ISR: cada encabezado explica qué y porqué, y se comentan aparte solo los valores mágicos y la aritmética con carry (un comentario por línea no es legible ni puntúa más).
- Montar el bucle infinito a)→d) — IN de los 4 puertos + STORE en su dirección RAM, operaciones condicionales de b)-d) encadenadas con JUMP entre apartados, y
JUMP INICIOal final de d) que cierra a)→d)→a). - Justificar el flag de cada decisión — COMP deja Z=1 en la coincidencia y CY marca el acarreo hacia fuera; en la tabla impresa ADD/SUB no leen la CY de entrada (solo la producen); TEST con H"80" deja Z=1 si el bit probado es 0, al revés de lo que parece: el JUMP se elige con ese criterio.
- Aprovechar lo que el hardware de interrupción ya hace solo — apila el PC, salva Z/C y enmascara, así que en el vector basta
JUMP ISR; la ISR borra las 3 salidas y TODA la RAM declarada (bucle indirecto con registro índice hasta H'1E') y termina conJUMP INICIOporque el enunciado exige reiniciar;EINTsolo se re-arma en INICIO, nunca dentro de la ISR. - Ejecutar el programa completo y comprobar cada rama — un ejemplo a mano con datos concretos por ambos lados de cada condición (con y sin acarreo, MSB=0 y MSB=1), más un emulador KCPSM con asserts de cada salida y de la ISR (3 puertos y RAM H'00'–H'1E' a 0, reinicio con
EINTre-armado).
Idea transversal: ceñirse siempre a la tabla de instrucciones impresa del examen (IN/OUT, STORE kk directo sin paréntesis, TEST con Z invertido) y no reimplementar por software lo que el hardware ya hace él solo: el CALL al vector, la pila y el enmascaramiento.