DISEÑO DE SISTEMAS

COMPUTACIONALES PARA
APLICACIÓN ESPECÍFICA
SESION 11
 LOGRO

Logros de la sesión
Al finalizar la sesión el estudiante estará en capacidad de:

El alumno modela máquinas de estado finito utilizando lenguaje VHDL

 UTILIDAD

Modelar máquinas de estados finitos en VHDL permite

diseñar y simular sistemas digitales complejos de manera
eficiente y precisa.
 TRANSFORMACIÓN

Conceptos básicos
Una Máquina de Estado Finito en VHDL se compone típicamente de los siguientes elementos:
Estados: Son las condiciones posibles en las que puede estar el sistema. Cada estado representa una
configuración particular del sistema.
Transiciones: Son los cambios de un estado a otro, generalmente disparados
 TRANSFORMACIÓN

Ejemplo práctico 1
ejemplo de una máquina de estados finita (FSM) para un semáforo con tiempos establecidos para cada luz
(rojo, amarillo y verde).
Supongamos los siguientes tiempos para las luces del semáforo:
Luz roja: 5 segundos
Luz amarilla: 2 segundos
Luz verde: 4 segundos
 TRANSFORMACIÓN

Librerías para
utilizar library IEEE:

Esta línea indica que vamos a usar librerías estándar definidas

library IEEE;
por el IEEE (Institute of Electrical and Electronics Engineers).
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_1164.ALL:
use IEEE.STD_LOGIC_UNSIGNED.ALL; STD_LOGIC_1164 es la librería que define los tipos de datos
lógicos más comunes en VHDL, como STD_LOGIC y
STD_LOGIC_VECTOR.STD_LOGIC: Tipo de dato que puede tener
varios valores (0, 1, Z (impedancia alta), X (desconocido), etc.),
muy útil para representar señales digitales.
STD_LOGIC_VECTOR: Un arreglo de STD_LOGIC, usado para
representar buses o conjuntos de señales.
.
 TRANSFORMACIÓN

Librerías para use IEEE.STD_LOGIC_ARITH.ALL:

utilizar STD_LOGIC_ARITH es una librería que proporciona tipos y
operaciones aritméticas. Aunque el uso de esta librería está
siendo reemplazado por NUMERIC_STD en diseños más
library IEEE;
modernos, aún es común en muchos proyectos.
use IEEE.STD_LOGIC_1164.ALL; Operaciones Aritméticas: Suma, resta, multiplicación y división
use IEEE.STD_LOGIC_ARITH.ALL; para tipos de datos STD_LOGIC_VECTOR.
use IEEE.STD_LOGIC_UNSIGNED.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL:

STD_LOGIC_UNSIGNED es una extensión que permite tratar

STD_LOGIC_VECTOR como números enteros sin signo.

Operaciones Aritméticas: Permite realizar operaciones

aritméticas directamente sobre vectores lógicos sin necesidad
de convertirlos primero a otros tipos.
 TRANSFORMACIÓN

Entidad
entity Semaforo_FSM is Define la interfaz del semáforo.
Port ( clk : in STD_LOGIC; Los puertos incluyen:
clk: Señal de reloj.
reset : in STD_LOGIC; reset: Señal de reinicio.
rojo, amarillo, verde : out STD_LOGIC); rojo, amarillo, verde: Salidas para las luces
end Semaforo_FSM; del semáforo.
 TRANSFORMACIÓN

Arquitectura
architecture Behavioral of Semaforo_FSM is Define el tipo de estado y las señales internas:
type tipo_estado is (ROJO, AMARILLO, VERDE); tipo_estado: Enumera los estados posibles del semáforo (ROJO,
AMARILLO, VERDE).
signal estado_actual, proximo_estado : tipo_estado;
signal contador : INTEGER range 0 to 500000000; estado_actual, proximo_estado: Señales para mantener el
signal retardo : INTEGER range 0 to 500000000; estado actual y el próximo estado.

contador: Un contador para implementar los retrasos.

constant retardo_ROJO : INTEGER := 500000000; -- 5 retardo: Señal para almacenar el valor del retraso para el
segundos (suponiendo reloj de 100 MHz) estado actual.
constant retardo_AMARILLO : INTEGER := 200000000;
-- 2 segundos retardo_ROJO, retardo_AMARILLO, retardo_VERDE: Constantes
constant retardo_VERDE : INTEGER := 400000000; -- 4 que definen los retrasos para cada estado en ciclos de reloj.
segundos
 TRANSFORMACIÓN

Proceso de Reloj y Reinicio

process(clk, reset) Si reset está activo (1), el estado actual se reinicia a ROJO y
begin el contador se reinicia a 0.
if reset = '1' then
estado_actual <= ROJO; En el flanco ascendente del reloj (rising_edge(clk)), el
contador <= 0; contador se incrementa hasta alcanzar el valor de retardo.
elsif rising_edge(clk) then
if contador = retardo then Cuando el contador alcanza el valor de retardo, el estado
estado_actual <= proximo_estado; cambia al siguiente y el contador se reinicia a 0.
contador <= 0;
else
contador <= contador + 1;
end if;
end if;
end process;
 TRANSFORMACIÓN

Proceso de la
máquina de estado
process(estado_actual) when VERDE =>
begin proximo_estado <= AMARILLO;
case estado_actual is rojo <= '0';
when ROJO => amarillo <= '0';
proximo_estado <= VERDE; verde <= '1';
rojo <= '1'; retardo <= retardo_VERDE;
amarillo <= '0'; when others =>
verde <= '0'; proximo_estado <= ROJO;
retardo <= retardo_ROJO; rojo <= '1';
when AMARILLO => amarillo <= '0';
proximo_estado <= ROJO; verde <= '0';
rojo <= '0'; retardo <= retardo_ROJO;
amarillo <= '1'; end case;
verde <= '0'; end process;
retardo <= retardo_AMARILLO; end Behavioral;
 TRANSFORMACIÓN

Proceso de la máquina de estado

Dependiendo del estado actual (estado_actual), se define el próximo estado (proximo_estado), las salidas (rojo,
amarillo, verde) y el valor del retraso (retardo) para cada estado.
ROJO: El próximo estado es VERDE, y la luz roja está encendida.
AMARILLO: El próximo estado es ROJO, y la luz amarilla está encendida.
VERDE: El próximo estado es AMARILLO, y la luz verde está encendida.
others: Por defecto, el estado se reinicia a ROJO.
 TRANSFORMACIÓN

Ejemplo práctico 2
Sistema de control de una máquina expendedora de refrescos. Este sistema tendrá los siguientes estados:

Este sistema tendrá los siguientes estados:

IDLE: Espera a que se inserte una moneda.
MONEDA_INSERTADA: Verifica si la cantidad de monedas es suficiente.
DISPENSA_BEBIDA: Dispensa la bebida si la cantidad de monedas es suficiente.
CAMBIO_DEVUELTO: Devuelve el cambio si hay monedas restantes.

Suposiciones:
La máquina expendedora acepta una moneda cada 1 segundo.
El costo de una bebida es de 2 monedas.
El tiempo para dispensar una bebida es de 3 segundos.
El tiempo para devolver el cambio es de 2 segundos.
 TRANSFORMACIÓN

Librerías a utilizar
library IEEE: Indica que usaremos librerías estándar definidas por el IEEE.

use IEEE.STD_LOGIC_1164.ALL: Proporciona tipos de datos lógicos

library IEEE;
(STD_LOGIC, STD_LOGIC_VECTOR) y operaciones lógicas.
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_ARITH.ALL: Proporciona tipos y operaciones
use IEEE.STD_LOGIC_UNSIGNED.ALL;
aritméticas.

use IEEE.STD_LOGIC_UNSIGNED.ALL: Permite tratar STD_LOGIC_VECTOR

como números enteros sin signo para operaciones aritméticas.
 TRANSFORMACIÓN

Entidad
Define la interfaz del sistema de control de la máquina
expendedora.
entity Maquina_Expendedora is
clk: Señal de reloj.
Port ( clk : in STD_LOGIC;
reset : in STD_LOGIC;
reset: Señal de reinicio.
moneda : in STD_LOGIC;
dispensar, devolver_cambio : out STD_LOGIC);
moneda: Señal de entrada indicando la inserción de una
end Maquina_Expendedora;
moneda.

dispensar: Señal de salida para dispensar una bebida.

devolver_cambio: Señal de salida para devolver el

cambio.
 TRANSFORMACIÓN

Arquitectura Define el tipo de estado y las señales internas.

tipo_estado: Enumera los estados posibles (IDLE,
MONEDA_INSERTADA, DISPENSA_BEBIDA,
CAMBIO_DEVUELTO).
architecture Behavioral of Maquina_Expendedora is estado_actual, proximo_estado: Señales para mantener el
type tipo_estado is (IDLE, MONEDA_INSERTADA, estado actual y el próximo estado.
DISPENSA_BEBIDA, CAMBIO_DEVUELTO); contador: Un contador para implementar los retrasos.
signal estado_actual, proximo_estado : tipo_estado; monedas: Señal que cuenta el número de monedas
signal contador : INTEGER range 0 to 500000000; insertadas.
signal monedas : INTEGER range 0 to 10; retardo: Señal para almacenar el valor del retraso para el
signal retardo : INTEGER range 0 to 500000000; estado actual.

constant retardo_MONEDA : INTEGER := 100000000; -- 1 Constantes de Retardo:

segundo retardo_MONEDA: Retardo de 1 segundo para la inserción
constant retardo_DISPENSA : INTEGER := 300000000; -- 3 de monedas.
segundos retardo_DISPENSA: Retardo de 3 segundos para dispensar
constant retardo_CAMBIO : INTEGER := 200000000; -- 2 la bebida.
segundos retardo_CAMBIO: Retardo de 2 segundos para devolver el
cambio.
 TRANSFORMACIÓN

Proceso de reloj y reset

process(clk, reset)
begin Reinicio: Si reset está activo (1), el estado actual se reinicia a
if reset = '1' then IDLE, el contador se reinicia a 0, y la cantidad de monedas se
estado_actual <= IDLE; reinicia a 0.
contador <= 0;
monedas <= 0; Reloj: En el flanco ascendente del reloj (rising_edge(clk)), el
elsif rising_edge(clk) then contador se incrementa hasta alcanzar el valor de retardo.
if contador = retardo then Cuando el contador alcanza el valor de retardo, el estado
estado_actual <= proximo_estado; cambia al siguiente y el contador se reinicia a 0.
contador <= 0;
else
contador <= contador + 1;
end if;
end if;
end process;
 TRANSFORMACIÓN

Proceso de proximo_estado <= IDLE; when others =>

Máquina de end if;
dispensar <= '0';
proximo_estado <= IDLE;
dispensar <= '0';
estado
process(estado_actual, moneda, monedas) devolver_cambio <= '0';
retardo <= retardo_MONEDA;
devolver_cambio <= '0';
retardo <= retardo_MONEDA;
begin
case estado_actual is when DISPENSA_BEBIDA => end case;
when IDLE => proximo_estado <= end process;
if moneda = '1' then CAMBIO_DEVUELTO; end Behavioral;
monedas <= monedas + 1; dispensar <= '1';
proximo_estado <= MONEDA_INSERTADA; devolver_cambio <= '0';
else retardo <= retardo_DISPENSA;
proximo_estado <= IDLE; when CAMBIO_DEVUELTO =>
end if; proximo_estado <= IDLE;
dispensar <= '0'; dispensar <= '0';
devolver_cambio <= '0'; devolver_cambio <= '1';
retardo <= retardo_MONEDA; monedas <= 0;
when MONEDA_INSERTADA => retardo <= retardo_CAMBIO;
if monedas >= 2 then
proximo_estado <= DISPENSA_BEBIDA;
else
 TRANSFORMACIÓN

Proceso de Máquina de estado

IDLE: Espera la inserción de una moneda. Si se inserta una moneda, incrementa el contador de monedas y transita al
estado MONEDA_INSERTADA.
Salidas: dispensar = '0', devolver_cambio = '0’.
Retardo: retardo = retardo_MONEDA.
MONEDA_INSERTADA: Verifica si se ha insertado la cantidad suficiente de monedas (2 monedas). Si es suficiente, transita
al estado DISPENSA_BEBIDA.
Salidas: dispensar = '0', devolver_cambio = '0’.
Retardo: retardo = retardo_MONEDA.
DISPENSA_BEBIDA: Dispensa la bebida y transita al estado CAMBIO_DEVUELTO.
Salidas: dispensar = '1', devolver_cambio = '0’.
Retardo: retardo = retardo_DISPENSA.
CAMBIO_DEVUELTO: Devuelve el cambio (si hay) y transita de vuelta al estado IDLE.
Salidas: dispensar = '0', devolver_cambio = '1’.
Monedas: monedas = 0.
Retardo: retardo = retardo_CAMBIO.
others: Por defecto, el estado se reinicia a IDLE.
Salidas: dispensar = '0', devolver_cambio = '0’.
Retardo: retardo = retardo_MONEDA.
 TRANSFORMACIÓN

Registro de datos y almacenamiento temporal

Un sistema donde los datos llegan en una secuencia de 4 bits y el sistema almacena temporalmente estos datos hasta
que recibe una señal de "almacenar", momento en el cual todos los datos almacenados temporalmente se trasladan a
un registro permanente.
Especificaciones del Sistema:
• El sistema tiene una entrada de 4 bits data_in.
• Una señal clk (reloj) que controla el proceso.
• Una señal store que indica cuándo almacenar los datos en el registro permanente.
• Un registro temporal que almacena 4 palabras de 4 bits.
• Un registro permanente que almacena los datos cuando se recibe la señal store.

Este diseño simula un sistema que recibe datos en paralelo, los almacena temporalmente y luego los
registra en un almacenamiento permanente al recibir una señal de "almacenar".
 TRANSFORMACIÓN

Librerias
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
 TRANSFORMACIÓN

Entidad
entity Registro_Datos is Define la interfaz del sistema de registro de datos.
Port ( clk : in STD_LOGIC;
clk: Señal de reloj.
reset : in STD_LOGIC;
data_in : in STD_LOGIC_VECTOR(3 downto 0); reset: Señal de reinicio.
store : in STD_LOGIC;
data_in: Entrada de datos de 4 bits.
data_out : out STD_LOGIC_VECTOR(15 downto 0));
end Registro_Datos; store: Señal que indica cuándo almacenar los datos
en el registro permanente.

data_out: Salida de datos del registro permanente

(16 bits).
 TRANSFORMACIÓN

Arquitectura
architecture Behavioral of Registro_Datos is
Define el tipo de estado y las señales internas.
type tipo_estado is (IDLE, ALMACENAR_TEMPORAL,
tipo_estado: Enumera los estados posibles (IDLE,
REGISTRAR);
ALMACENAR_TEMPORAL, REGISTRAR).
signal estado_actual, proximo_estado : tipo_estado; estado_actual, proximo_estado: Señales para mantener el
signal temp_reg : STD_LOGIC_VECTOR(15 downto 0); -- estado actual y el próximo estado.
Registro temporal de 4 palabras de 4 bits temp_reg: Registro temporal de 4 palabras de 4 bits.
perm_reg: Registro permanente de 4 palabras de 4 bits.
signal perm_reg : STD_LOGIC_VECTOR(15 downto 0); --
Registro permanente de 4 palabras de 4 bits contador: Contador para las palabras (0 a 3).

signal contador : INTEGER range 0 to 3; -- Contador para las

palabras
 TRANSFORMACIÓN

Proceso de Reloj y Reset

process(clk, reset)
Reinicio: Si reset está activo (1), el estado actual se reinicia a
begin
IDLE, los registros temporales y permanentes se reinician a 0, y
if reset = '1' then el contador se reinicia a 0.
estado_actual <= IDLE;
Reloj: En el flanco ascendente del reloj (rising_edge(clk)), el
temp_reg <= (others => '0');
estado actual se actualiza al próximo estado.
perm_reg <= (others => '0');
contador <= 0;
elsif rising_edge(clk) then
estado_actual <=
proximo_estado;
end if;
end process;
 TRANSFORMACIÓN

Proceso de Máquina de Estados

process(estado_actual, store, contador) contador <= contador + 1;
begin proximo_estado <= IDLE;
case estado_actual is else
when IDLE => temp_reg(15 downto 12) <= data_in; -- Almacena la
if store = '1' then última palabra
proximo_estado <= proximo_estado <= REGISTRAR;
ALMACENAR_TEMPORAL; end if;
else when REGISTRAR =>
proximo_estado <= IDLE; perm_reg <= temp_reg;
end if; proximo_estado <= IDLE;
when ALMACENAR_TEMPORAL => when others =>
if contador < 3 then proximo_estado <= IDLE;
temp_reg((contador+1)*4-1 downto end case;
contador*4) <= data_in; end process;
 TRANSFORMACIÓN

Proceso de máquina de estado

IDLE: Espera la señal store. Si store es 1, transita al estado ALMACENAR_TEMPORAL.

ALMACENAR_TEMPORAL:

Si el contador es menor que 3, almacena la palabra de 4 bits en temp_reg en la posición correspondiente y

aumenta el contador en 1.

Si el contador es igual a 3, almacena la última palabra y transita al estado REGISTRAR.REGISTRAR: Transfiere los
datos del registro temporal temp_reg al registro permanente perm_reg y transita de vuelta al estado IDLE.

others: Por defecto, el estado se reinicia a IDLE.

 TRANSFORMACIÓN

Asignación de salida
data_out <= perm_reg; Asigna el valor del registro permanente perm_reg a la salida
data_out.

Este diseño simula un sistema que recibe datos en paralelo, los almacena temporalmente y luego los
registra en un almacenamiento permanente al recibir una señal de "almacenar".
 ESPACIO PRÁCTICO

Ejercicio practico
Diseña una máquina de estados finita (FSM) con tres estados para controlar un temporizador que encienda un LED durante 5
segundos cada vez que se presione un botón. Los estados son:
• IDLE: Estado inicial en el que el sistema espera la activación del botón.
• ENCENDIDO: Estado en el que el LED está encendido durante 5 segundos.
• APAGADO: Estado en el que el LED está apagado.

El sistema debe seguir este comportamiento:

• Cuando el sistema está en el estado IDLE y se presiona el botón, transita al estado ENCENDIDO.
• En el estado ENCENDIDO, el LED debe permanecer encendido durante 5 segundos y luego transitar al estado APAGADO.
• En el estado APAGADO, el LED debe permanecer apagado indefinidamente hasta que se presione nuevamente el botón
para volver al estado IDLE.

La FSM debe garantizar que el LED se encienda durante 5 segundos cada vez que se presiona el botón, independientemente
de cuánto tiempo se mantenga presionado el botón.
 CIERRE

Preguntas?
 CIERRE

Conclusiones
El uso de VHDL para diseñar Máquinas de Estados Finitos (FSM) permite una descripción precisa de sistemas
digitales, facilitando la simulación y depuración antes de su implementación. Esta metodología promueve la
reusabilidad del código y mejora la eficiencia en el desarrollo de proyectos de hardware. VHDL es esencial para
ingenieros que buscan crear sistemas electrónicos complejos y fiables.
MUCHAS GRACIAS