Instituto Tecnológico de Tijuana

Departamento de Ingeniería Eléctrica y Electrónica

Ingeniería Electrónica

Diseño digital con VHDL

Práctica No. 4
Semáforo en VHDL

García Zavala Miguel Ángel 20211589

Gómez Martínez Melannie Giovanna 20211591
Urrea Soto Alberto 19212354
Imparte clase: Dr. Maldonado Robles Yazmin

Tijuana, Baja California 24 de octubre de 2022.

 Instituto Tecnológico de Tijuana
ÍNDICE DE CONTENIDO

I. INTRODUCCIÓN ........................................................................................................................3
II. MARCO TEÓRICO ......................................................................................................................3
III. OBJETIVO ................................................................................................................................4
IV. MATERIAL Y EQUIPO ...........................................................................................................4
V. PROCEDIMIENTO Y METODOLOGÍA EXPERIMENTAL ....................................................4
VI. SESIÓN DE REVISIÓN .........................................................................................................11
VII. DISCUSIÓN DE LOS RESULTADOS EXPERIMENTALES .............................................11
VIII. CONCLUSIONES ..................................................................................................................12
IX. BIBLIOGRAFÍA .....................................................................................................................12
X. ANEXO.......................................................................................................................................13

ÍNDICE DE FIGURAS
Figura 1. Diagrama de estados del semáforo .......................................................................................4
Figura 2. Asignación de entradas, salidas y señales. ............................................................................6
Figura 3. Divisor de frecuencia de 1 Hz. ..............................................................................................7
Figura 4. Programación del Segundero con un rango de 1 a 71 segundos. ..........................................7
Figura 5. Estados verde y apagado. ......................................................................................................8
Figura 6. Estados amarillo y rojo. ........................................................................................................8
Figura 7. Actualizador de estados. .......................................................................................................9
Figura 8. Asignación de Pines. .............................................................................................................9
Figura 9. Esquemático del semáforo. .................................................................................................10

ÍNDICE DE TABLAS

Tabla 1. Tabla de transiciones ..............................................................................................................5

 Instituto Tecnológico de Tijuana
I. INTRODUCCIÓN
En esta práctica se utilizará VHDL para sintetizar máquinas de estado, además de utilizar un
contador, esto con el objetivo de crear un semáforo que presente las luces que lo caracterizan de
acuerdo a las condiciones que se piden, creando primero un diagrama de estados que muestre el
funcionamiento de este en forma de teoría que presente la idea que se tiene para realizar las
condiciones que queremos mediante un código en la herramienta Vivado.
Para crear la síntesis se debe elegir primero qué máquina de estados es mejor utilizar de acuerdo
al proyecto a realizar, eligiendo para esta práctica la máquina de estados tipo Moore, ya eligiendo
se puede empezar a crear un diagrama de estados de los cuales se va a hacer uso y escogiendo las
estructuras preferentes para el tipo de código que queremos efectuar.
La máquina de tipo Moore a emplear estará compuesta por 4 estados, los cuales son dependientes
de un contador que irá desde 0 a 71 segundos, con el propósito de que las luces del semáforo sean
mostradas durante cierto tiempo cada una, utilizando 3 leds representantes de este conectados a un
circuito que seguirá las condiciones especificadas en nuestro código. Mientras que el código estará
optimizado lo mejor posible utilizando compuertas lógicas, y estructuras condicionales como if-
then-else y case-when, todos estos dentro de un process.

II. MARCO TEÓRICO

Un contador es un circuito secuencial cuya función es seguir una cuenta o conjunto
predeterminado de estados binarios como consecuencia de un tren de pulsos (reloj) en una de sus
entradas [1].
Una máquina de estado finita (FSM) representa un sistema como un conjunto de estados,
transiciones entre estos estados, que dependen de las entradas. De modo tal que una máquina de
estados en una representación, de un circuito secuencial particular [2].
El diseño de una FSM está compuesto por lo siguiente:

● Diagrama de estados: Ilustra la forma y funcionamiento de la máquina de estado.

● Estado: Un conjunto identificable y único de valores medidos en diversos puntos de un
sistema digital.

● Ramificación: El cambio del estado presente al estado siguiente.

● Estado(s) siguiente(s).
Máquina de estados Moore: Las salidas son independientes de las entradas. Las salidas se
producen efectivamente desde dentro del estado de la máquina. Es decir, sus salidas solo dependen
del estado de la máquina [3].
Compuertas lógicas: En VHDL las compuertas lógicas se utilizan como operadores lógicos, estos
nos permiten construir diferentes tipos de expresiones mediante los cuales podemos calcular datos
utilizando diferentes señales [4].
 Instituto Tecnológico de Tijuana
III. OBJETIVO
Diseñar en VHDL e implementar en el FPGA un semáforo vehicular utilizando máquinas de
estado finito (FSM).

IV. MATERIAL Y EQUIPO

● Basys 3
● Vivado
● Protoboard
● 3 leds (1 rojo, 1 ámbar y 1 verde)
● 3 resistencias
● Cable estañado para conexiones

V. PROCEDIMIENTO Y METODOLOGÍA EXPERIMENTAL

1. Dibuje el diagrama de estados y la tabla de transiciones para el semáforo vehicular, el cual
tiene el siguiente funcionamiento.
o El semáforo cuenta con 3 luces (verde, ámbar y rojo)
o La luz verde permanece encendida durante 40 seg, enseguida, parpadea 3 veces con
duración de 1 seg
o La luz ámbar permanece encendida durante 5 seg
o La luz roja estará́ encendida durante 20 seg
o El ciclo se repite

Figura 1. Diagrama de estados del semáforo

 Instituto Tecnológico de Tijuana
En el diagrama se pueden observar los estados, los cuales son 4 (estado 0, estado 1, estado 2 y
estado 3), las transiciones se darán cuando se cumplan las condiciones las cuales dependen del
estado en el que se encuentra.
Observando que las transiciones entre los estados se dan en 1 segundo, y las flechas de continuidad
en un mismo estado dependen del tiempo, en este caso si el estado dura más de 1 segundo se agrega
esa flecha de continuidad.

Edo. Presente Edo. Futuro Salida

Tiempo

Verde Verde<41, Amarillo =46, Apagado=40,42,44 001

Apagado Verde=41,43,45 000

Amarillo Rojo=52, Amarillo<53 010

Rojo Verde=71, Rojo<72 100

Tabla 1. Tabla de transiciones

En la tabla de transiciones podemos observar los estados presentes, y las transiciones hacia el estado
futuro que se darán en el tiempo que corresponden a nuestras condiciones.

2. Diseñe y simule el código VHDL.

3. Para la implementación, utilice una de las expansiones de la tarjeta Basys-3, coloque tres
Leds (verde, ámbar y rojo) y valide el funcionamiento del semáforo.
De lo anterior:
- De acuerdo al problema elija el tipo de FSM que se necesita - Ofrezca sus conclusiones
4. Revisar:
● Case
● IF
● Mealy
● Moore
 Instituto Tecnológico de Tijuana
Divisores de Frecuencia.
Para dar comienzo a la práctica primero se debe de realizar la escala el divisor de frecuencia
que se utilizará, para empezar, se debe tener en cuenta que la Basys 3 cuenta con un reloj
interno de 100 MHz por lo que sabiendo esto se puede continuar, para tener un reloj se necesita
un divisor que vaya a un segundo por lo que se utiliza un divisor de frecuencia de 1 Hz, para
obtener dicha frecuencia se debe de emplear la ecuación (1):
𝑅𝑒𝑙𝑜𝑗 𝑖𝑛𝑡𝑒𝑟𝑛𝑜 𝐸𝑠𝑐𝑎𝑙𝑎
𝐸𝑠𝑐𝑎𝑙𝑎 𝑥 𝐻𝑧 = 𝐹𝑟𝑒𝑐𝑢𝑒𝑛𝑐𝑖𝑎 𝑎 𝑟𝑒𝑑𝑢𝑐𝑖𝑟 −> 𝐹𝑟𝑒𝑐𝑢𝑒𝑛𝑐𝑖𝑎 𝑥 𝐻𝑧 = 2 (1)
Como se puede observar en la Figura 2 después de obtener la escala para 1 Hz se dividió entre
dos, esto se debe a que durante la mitad del tiempo la señal permanece alta (en 1) y la otra mitad
la señal permanecerá baja (en 0).
100 𝑀𝐻𝑧 10𝑥10−6
𝐸𝑠𝑐𝑎𝑙𝑎 1 𝐻𝑧 = 1 𝐻𝑧 = 10𝑥106 −> 𝐹𝑟𝑒𝑐𝑢𝑒𝑛𝑐𝑖𝑎 1 𝐻𝑧 = 2
= 5𝑥106 (2)
Para la programación del semáforo se utilizó la biblioteca estándar de IEEE, con los paquetes
de IEEE.STD_LOGIC_1164.ALL, IEEE.NUMERIC_STD.ALL siendo esta la que permite realizar
operaciones matemáticas y por último IEEE.STD_LOGIC_UNSIGNED.ALL la que define que el
bit más significativo de un vector no será un signo, posteriormente en la entidad denominada
como “PRACTICA4P1” se asignaron las entradas y salidas, siendo las entradas clk (reloj interno
de la Basys 3) definida como tipo de dato std_logic y la otra entrada “reset” (como su nombre lo
indica hará la función de reiniciar el conteo cuando sea activada) fue definida como tipo de dato
bit después de asignar las entradas se asignó la única salida la cual es led (se encargará de
encender los 3 leds que conforman al semáforo) definida como tipo de dato std_logic_vector(2
downto 0), posteriormente se terminó la entidad, en la arquitectura denominada como “Semáforo”
se definieron las señales las cuales ayudarán en los diferentes procesos, la primera que se
definió fue “aux” (divisor de frecuencia de 1 Hz) como tipo de dato std_logic y con un valor inicial
de ´0´, la segunda señal es “segundero” (Servirá para realizar el conteo en segundos del 1 al 71)
como tipo de dato integer o entero con un rango de 1 a 71 (recordando que serán los segundos
que se utilizaran en total para el semáforo), la tercera cosa en ser asignada fue “estados” como
tipo type con “s0”,”s1”,s2” y “s3” como los tipos de estados (representan al verde, apagado,
amarillo y rojo) y por último la señal “edo_presente” y “edo_futuro” que servirán para ir cambiando
de estados (de verde a amarillo, de amarillo a rojo, etc), todas estas declaraciones se pueden
observar en la siguiente Figura 2.

Figura 2. Asignación de entradas, salidas y señales.

 Instituto Tecnológico de Tijuana
El siguiente paso que se realizó fue el divisor de frecuencia para el contador, por lo que primero se
asignó un proceso que depende del reloj interno, dentro del proceso se asignó una variable
denominada como “cuentahz” con tipo de dato entero con un rango de 1 a 50,000,000 siendo este
rango lo calculado en la ecuación (2), posteriormente se empezó el proceso, donde si el “reset” se
encuentra activado la “cuentahz” valdrá 1 por lo que el conteo se reiniciará, de lo contrario cuando la
señal del reloj se encuentre en alto se irá sumando constantemente 1 a “cuentahz” hasta que llegue
50,000,000 y cuando llegue a dicho número el conteo se reiniciará, para finalizar el divisor de
frecuencia de 1 Hz se cerró el proceso, véase en la Figura 3.

Figura 3. Divisor de frecuencia de 1 Hz.

En la Figura 4. se muestra el código del segundero que tendrá un rango de 1 a 71 esto a debido a que es el
tiempo que tarda en completar un ciclo el semáforo, se utilizó un proceso que depende del “aux” y del “reset”
y donde se utiliza la señal de “segundero” dentro del proceso ya antes mencionado, lo primero que se definió
al empezar el proceso fue que en el caso que “reset” esté activado el “segundero” valdrá 1, de lo contrario
en cada alto del divisor de frecuencia de un 1 Hz, se irá sumando uno en uno al mismo “segundero” hasta
que llegue a un valor de 71 y cuando este sea el caso el “segundero” volverá a valer 0 , para finalizar el
segundero se cerró el proceso.

Figura 4. Programación del Segundero con un rango de 1 a 71 segundos.

 Instituto Tecnológico de Tijuana
Para declarar que hará cada estado se utilizó un proceso, por lo que dentro de este se declaró
que dependerá del estado presente y del segundero, empezando el proceso se utilizó un case
que se encargará de mandar la salida dependiendo del estado en el que se encuentre, el primer
estado llamado “s0” (o verde) estará presente hasta que el segundero llegue a los 40 segundos,
justo al llegar a los 40 segundos pasará al segundo estado llamado “s1” (o apagado) donde el
estado presente será el mismo “s1” hasta que llegue a 41 segundos, este patrón se mantendrá
así, pasando entre “s0” y “s1”, lo que creará el parpadeo de la luz verde, esto será así hasta
llegar al segundo 46 donde el estado presente es “s0” y el estado futuro será “s2” por lo que
pasará al tiempo de encendido de la luz amarilla. véase en la Figura 5.

Figura 5. Estados verde y apagado.

Al pasar al “s2” se utilizara un if para limitar el tiempo en el que estará encendido el led amarrillo,
siendo que se tiene que cumplir dos condiciones las cuales son las siguientes, que el tiempo sea
mayor a 46 segundos y menor a 51 segundo dando como resultado 5 segundos en los que se
encontrara en el estado “s2”, de lo contrario cuando sobrepase los 51 segundos pasará al estado
“s3” (luz roja), para el estado “s3” el caso es similar, con la diferencia que el rango es mayor de
51 segundos y menor que 71 segundos cuando esto no se cumpla el estado futuro será “s0”.

Figura 6. Estados amarillo y rojo.

 Instituto Tecnológico de Tijuana
Para finalizar con VHDL, se utilizó un proceso el cual depende del reset y del aux, este proceso
servirá para estar actualizando el estado presente, primero se definió que si el reset se encuentra
activado entonces el estado presente será el primer estado (s0) de lo contrario en cada alto de
la señal de 1 Hz el estado presente valdrá lo mismo que el estado futuro.

Figura 7. Actualizador de estados.

Para finalizar con la programación en Vivado se hizo la asignación de los pines, para lo cual
primero se asigno a CLK al pin del reloj interno de la Basys 3, para el encendido de los leds de
los diferentes colores (amarillo, verde, rojo) se le asigno a tres pin headers estos se encuentran
en los Pmod Ports y por último se asignó el reset a un switch, véase en la Figura 8.

Figura 8. Asignación de Pines.

En la Figura 9 se puede observar el esquemático de la programación del semáforo, donde se

encuentran 7 multiplexores, memorias, 6 comparadores, una compuerta lógica Not, cuatro
compuertas OR, dos compuertas AND, las dos entradas (reset, clk) y la salida (led).
 Instituto Tecnológico de Tijuana

Figura 9. Esquemático del semáforo.

 Instituto Tecnológico de Tijuana
VI. SESIÓN DE REVISIÓN

¿Cuál es la función del reset en esta práctica? El reset es el que reinicia el proceso y vuelve a
empezar

¿Que afecta al activarlo? La parte del segundero que es el contador de cada segundo que va
transcurriendo para de este modo el semáforo empiece de nuevo

VII. DISCUSIÓN DE LOS RESULTADOS EXPERIMENTALES

En el transcurso de elaboración de la práctica se presentaron distintas dificultades tanto en el código

como en el diagrama, debido a problemas del cómo organizar los pasos los cuales el código iba a
seguir, estos principalmente se observaron en el diagrama ya que colocamos de manera equivocada
el cambio de estado presente a estado futuro y el momento que iba a mantener activado cada uno de
estos.

Otra de las dificultades al terminar el código VHDL fue la ejecución en el Protoboard y ya que en el
momento desconocíamos el cómo mostrarlo y por problemas de conexión se nos dificulto aún más el
muestreo en él, pero preguntando e investigando pudimos pasarlo al Protoboard de manera exitosa y
de esta manera tener los resultados esperados de un semáforo en funcionamiento con los cambios de
verde a amarillo con sus respectivos parpadeos y posteriormente de amarillo a rojo repitiéndose en
forma de loop, hasta que el reset sea activado y funcione como un reseteo del programa realizado.
 Instituto Tecnológico de Tijuana
VIII. CONCLUSIONES
García: Esta práctica nos sirvió para comprender mejor el funcionamiento de las máquinas
de estado tipo Moore, debido a que pudimos programar esta máquina para realizar un
semáforo, también comprendimos mas acerca de como poner los rangos de tiempo para
encender los leds que corresponden en el tiempo adecuado.

Gómez: En el transcurso del proyecto pudimos aprender más sobre máquinas de estado finito,
completando con éxito lo solicitado y obteniendo experiencia en cuanto a como programar
en VHDL.

Urrea: La práctica realizada, nos ayudó a observar y aprender distintas maneras de llegar a
realizar en código distintas acciones con un proceso determinado, gracias a la investigación
y preguntas realizadas en clase fuimos capaces de conocer un poco más sobre la
programación de VHDL, por dudas que fuimos aclarando en el curso de la investigación nos
dio mayor facilidad realizando el proceso de cada función por el hecho de saber el cómo
trabaja cada línea de código realizada.

IX. BIBLIOGRAFÍA

[1] T. D. Catillo, «Contador ascendente y descendente en VHDL,» Ecuador, s/f. .

[2] M. Cassanovas, «F. S. M. Máquinas de estados,» julio 2014. [En línea].

Available: https://www.profesores.frc.utn.edu.ar/electronica/tecnicasdigitalesi/pub/file

/AportesDelCudar/Maquinas%20de%20Estado%20MC%20V5.pdf. [Último acceso: 13 octubre 2022].

[3] M. L. Guillarme, 27 06 2000. [En línea].

Available: http://delta.cs.cinvestav.mx/~gmorales/ta/node50.html.

[4] S.-É. Marcos, «Introducción a la programación en VHDL,» julio 2014. [En línea].

Available: https://eprints.ucm.es/id/eprint/26200/1/intro_VHDL.pdf. [Último acceso: 22 octubre

2022].
 Instituto Tecnológico de Tijuana

X. ANEXO