Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Práctica No. 3.
Aplicaciones de circuitos combinacionales y secuenciales.
Combinational and secuential circuits applications.

Cree en tí y todo será posible.

Unidad Temática: II

Duración y entrega: indicadas en la plataforma

Intrucciones: En estas prácticas se reportarán las simulaciones o un video de sus resultados,

dependiendo del equipo que tengan. Los que tengan tarjeta reportarán un video de los
resultados y los códigos (VHDL, V, ucf, xdc, csv). Los que NO tengan tarjeta reportarán las
simulaciones junto con los códigos (VHDL, V, ucf) para la tarjeta Nexys 2.

Contenido:
En esta práctica se implementarán/simularán los siguientes circuitos:
• Contador de pulso en alto en ms con salida a display hasta 9999 al presionar un botón,
con beep y led RGB indicando el rango, mensaje de termino de conteo y reset.
• Control de posición de un servomotor (0°-180°) con encoder rotatorio.

Introducción.
Introduction.

Encoder

Un encoder rotatorio mecánico consta de por lo menos dos interruptores que se cierran en
diferentes posiciones cuando su eje gira. La secuencia generada en los interruptores A y B
es: 00→10→11→01→00, lo que se conoce como código Gray. En la figura 3.1 se muestran
los encoder y su diagrama interno. Es posible cambiar un poco el mecanismo y los sensores
para tener un encoder rotatorio óptico o magnético, empleando optointerruptores y sensores
de efecto hall junto con imanes, respectivamente.

1
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Figura 3.1. Foto del encoder mecánico (a), circuito eléctrico equivalente (b), encoder
magnético (c) y encoder óptico (d).

PWM

La modulación de ancho de pulso también conocida como PWM permite cambiar el voltaje
promedio de una señal, tal como se puede ver en la figura 3.2. Dicha señal es muy utilizada
para el control de posición en un servomotor con tope o control de velocidad y sentido de
giro en un servomotor de movimiento contínuo o sin tope, lo que se aprecia en la figura 3.9.

Figura 3.2. Voltaje medio de una señal. (a) Vm bajo, (b) Vm medio y (c) Vm alto.

Dicha señal es muy utilizada para el control de posición en un servomotor con tope o control
de velocidad y sentido de giro en un servomotor de movimiento contínuo o sin tope, lo que
se aprecia en la figura 3.3.

2
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Figura 3.3. PWM que se controla la posición de un servomotor de forma genérica con una
señal de T=10ms ó f=100Hz y señal en alto de 1ms a 2ms. (a) va a 0° con 1ms, (b) va a 90°
con 1.5ms y (c) va a 180° con 2ms.

En seguida se presenta un ejemplo escrito en VHDL que al girar el eje del encoder en
cualquier sentido, cambia la posición de un servomotor con tope, debido a que se modifica
el PWM conectado a la señal de control. El cambio en el PWM se observa en un led testigo
cambiando su intensidad y también se visualizan los cambios de posición en 5 leds de forma
binario y en un display de 7 segmentos las 32 posiciones (0 a F y 0. a F.), a parte de los
movimientos del servo.

Las características del servomotor FUTABA S3003 con el que se diseñó el programa son:
Tiempo en alto
Ángulo High
0° 0.3ms
180° 2.3ms

Tomando en cuenta que se tiene un reloj de 50MHz que da un periodo T=20ns, se calculan
las veces que cabe el periodo en el tiempo en alto y en el incremento, quedando de la siguiente
forma:
Tiempo en alto [ms]
Ángulo high Constantes Observaciones
0° 0.3ms (@cnt=0) high/20ns=15000 Se llamará “min”
180° 2.3ms (@cnt=31)
Incremento = Incremento =
(180°-0°)/31 (2.3-0.3=2ms)/31 = 64.516us incremento=3225 Se llamará “inc”
64.516us/20ns = 3225.8

El programa presenta la implementación de una función bajo el criterio de que se parte de un

valor inicial (15000@cnt=0) en el conteo de “cnt” y los valores subsecuentes se incrementan
en aproximadamente 6666 para 16 posiciones y 3225 para 32 posiciones, se puede modelar
el valor del conteo del PWM que se comparará con en valor de cntPWM de la siguiente
forma:
high <= 15000 + (cnt * 3225) para las 32 posiciones
high <= min + ((cnt)*(inc)) para el código;

cuyo resultado en la señal de PWM para el servo se muestra en la siguiente figura 3.4

3
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Figura 3.4. Tres ejemplos de la señal de PWM generadas por el código en VHDL.

------------------------------------------------------------------------------------------------------
-- Se presenta un generador de señal PWM para controlar un servomotor, utilizando un
-- encoder rotatorio mecánico para manipular su posición. El sentido de giro es CW y
-- CCW, tanto para el encoder como para el servomotor, teniendo un tope en ambos
-- sentidos. El tiempo en alto “high” se obtiene con la función Ta=K1+(conta*K2) o bien
-- high <= min + (cnt*inc), colocada como high = 15000 + (cnt * 3225).
-- Archivos: [Link] y [Link], ServoconEncoderPos (proyecto)
------------------------------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity encoder is
Generic ( msb : integer := 5; --número de bits del contador
min : integer := 18332; --valor mínimo del contador para el tiempo en alto
max : integer := 121686; --valor máximo del contador para el tiempo en alto
inc : integer := 3334; -- incremento para el tiempo en alto
N : integer := 15 ); --divisor
Port (
--reloj de 50MHz de la nexys2
clk : in STD_LOGIC;
--reset asíncrono en alto en la nexys2 (BTN0) y en el encoder (Push)
resetB,resetP: in STD_LOGIC;
--señales A y B del encoder
A,B : in STD_LOGIC;
--salida del contador de 5 bits cuando msb=5
contador : out STD_LOGIC_VECTOR (msb-1 downto 0);
--salida a display de 7 segmentos + P
display : out STD_LOGIC_VECTOR (7 downto 0):="00000001";
--salida a los ánodos
AN : out STD_LOGIC_VECTOR (0 to 3);
--salidas de pwm para el servomotor y un led testigo
servomotor,servoLED : out STD_LOGIC
);
end encoder;

4
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

architecture encoder of encoder is

--se utiliza una FSM moore para leer el encoder
type edos is (EA, EB, EC, ED);
signal EP: edos:=EA;

--declaración de señales
signal clkdiv: std_logic_vector(N downto 0); --señal para el divisor
signal AB: std_logic_vector (1 to 2); --señal que une las señales del encoder
signal cntPWM: integer range 1 to 500000 := 1; --contador de 10ms @ clk=50MHz
-- o T=20ns
signal cnt: integer range 0 to 31:= 0; --contador de 0 a 31
signal servo: std_logic; --señal de PWM para las salidas servos
signal high: integer range min to max := min; --duración del tiempo en alto de la
-- señal PWM
------------ end signal declarations ------------
begin

AB <= a & b; --unión (concatenación) de las señales del encoder

AN <= "1110"; --activación del ánodo del display uno

divisor: --proceso del divisor

process(clk,resetB,resetP)
begin
if resetB = '1' or resetP = '1' then clkdiv <= (others => '0');
elsif rising_edge(clk) then clkdiv <= clkdiv + 1;
end if;
end process divisor;

FSM: --proceso que detecta los giros del encoder y genera la variable cnt
process (clkdiv(N),resetB,resetP,cnt)
begin
if resetB = '1' or resetP = '1' then EP <= EA; cnt<=0;
elsif rising_edge(clkdiv(N)) then
case EP is
when EA =>
if AB = "00" then EP <= EA; cnt<=cnt; --hold
elsif AB = "10" then EP <= EB; --cw
if cnt = 31 then cnt <= 31;
elsif cnt < 31 then cnt <= cnt + 1;
else cnt <= cnt;
end if;
elsif AB = "01" then EP <= ED; --ccw
if cnt = 0 then cnt <= 0;
elsif cnt > 0 then cnt <= cnt - 1;
else cnt <= cnt;
end if;

5
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

end if;
when EB => cnt <= cnt; --hold
if AB = "10" then EP <= EB;
elsif AB = "11" then EP <= EC;
elsif AB = "00" then EP <= EA;
end if;
when EC =>
if AB = "11" then EP <= EC; cnt<=cnt; --hold
elsif AB = "01" then EP <= ED; --cw
if cnt = 31 then cnt <= 31;
elsif cnt < 31 then cnt <= cnt + 1;
else cnt <= cnt;
end if;
elsif AB = "10" then EP <= EB; --ccw
if cnt = 0 then cnt <= 0;
elsif cnt > 0 then cnt <= cnt - 1;
else cnt <= cnt;
end if;
end if;
when ED => cnt <= cnt; --hold
if AB = "01" then EP <= ED;
elsif AB = "00" then EP <= EA;
elsif AB = "11" then EP <= EC;
end if;
when others => null;
end case;
end if;
end process FSM;

-- Proceso para generar la salida de PWM de 0.3 a 2.3 ms @ f=100Hz, cntPWM cuenta
-- de 1 a 500,000 que equivale a un periodo de 10ms, con 16 posiciones, high va de
-- min @ cnt=0 (0.3ms) hasta max @ cnt=15 (2.3ms).
--
-- Los valores de high para (cnt) con incrementos de 6666 son:
-- 0.3ms (0), 0.4333ms (1), 0.5666ms (2), 0.7ms (3),
-- 0.8333ms (4), 0.9666ms (5), 1.1ms (6), 1.2333ms (7),
-- 1.3666ms (8), 1.5ms (9), 1.6333ms (10), 1.7666ms (11),
-- 1.9ms (12), 2.0333ms (13), 2.1666ms (14), 2.3ms (15)
--
-- Con 32 posiciones high va de min @ cnt=0 (0.3ms) hasta max @ cnt=31 (2.3ms).
-- Los valores de high para (cnt) con incrementos de 3225 son:
-- 0.3ms (0), 0.365ms (1), 0.429ms (2), 0.494ms (3),
-- 0.558ms (4), 0.623ms (5), 0.687ms (6), 0.752ms (7),
-- 0.816ms (8), 0.881ms (9), 0.945ms (10), 1.01ms (11),
-- 1.074s (12), 1.139ms (13), 1.203ms (14), 1.268ms (15)
-- 1.332ms (16), 1.397ms (17), 1.467ms (18), 1.526ms (19),
-- 1.59ms (20), 1.655ms (21), 1.719ms (22), 1.784ms (23),

6
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

-- 1.848ms (24), 1.913ms (25), 1.977ms (26), 2.042ms (27),

-- 2.106ms (28), 2.171ms (29), 2.235ms (30), 2.3ms (31)

ModulPulso: --proceso que genera el pulso de salida e indica en el display un valor

process(clk,servo)
begin
if rising_edge(clk) then cntPWM <= cntPWM + 1; --contador de 1 a 500,000
high <= min + ((cnt)*(inc));
if cntPWM <= high then servo <= '1';
else servo <= '0';
end if;
case cnt is --orden: abcdefgP-ánodo común, contador = salida a leds
when 0 => display <= "00000011"; contador <= '0' & x"0"; -- 0 al display
when 1 => display <= "10011111"; contador <= '0' & x"1"; -- 1 al display
when 2 => display <= "00100101"; contador <= '0' & x"2"; -- 2 al display
when 3 => display <= "00001101"; contador <= '0' & x"3"; -- 3 al display
when 4 => display <= "10011001"; contador <= '0' & x"4"; -- 4 al display
when 5 => display <= "01001001"; contador <= '0' & x"5"; -- 5 al display
when 6 => display <= "01000001"; contador <= '0' & x"6"; -- 6 al display
when 7 => display <= "00011111"; contador <= '0' & x"7"; -- 7 al display
when 8 => display <= "00000001"; contador <= '0' & x"8"; -- 8 al display
when 9 => display <= "00001001"; contador <= '0' & x"9"; -- 9 al display
when 10 => display <= "00010001"; contador <= '0' & x"A"; -- A al display
when 11 => display <= "11000001"; contador <= '0' & x"B"; -- B al display
when 12 => display <= "01100011"; contador <= '0' & x"C"; -- C al display
when 13 => display <= "10000101"; contador <= '0' & x"D"; -- D al display
when 14 => display <= "01100001"; contador <= '0' & x"E"; -- E al display
when 15 => display <= "01110001"; contador <= '0' & x"F"; -- F al display
when 16 => display <= "00000010"; contador <= '1' & x"0"; -- 0. al display
when 17 => display <= "10011110"; contador <= '1' & x"1"; -- 1. al display
when 18 => display <= "00100100"; contador <= '1' & x"2"; -- 2. al display
when 19 => display <= "00001100"; contador <= '1' & x"3"; -- 3. al display
when 20 => display <= "10011000"; contador <= '1' & x"4"; -- 4. al display
when 21 => display <= "01001000"; contador <= '1' & x"5"; -- 5. al display
when 22 => display <= "01000000"; contador <= '1' & x"6"; -- 6. al display
when 23 => display <= "00011110"; contador <= '1' & x"7"; -- 7. al display
when 24 => display <= "00000000"; contador <= '1' & x"8"; -- 8. al display
when 25 => display <= "00001000"; contador <= '1' & x"9"; -- 9. al display
when 26 => display <= "00010000"; contador <= '1' & x"A"; -- A. al display
when 27 => display <= "11000000"; contador <= '1' & x"B"; -- B. al display
when 28 => display <= "01100010"; contador <= '1' & x"C"; -- C. al display
when 29 => display <= "10000100"; contador <= '1' & x"D"; -- D. al display
when 30 => display <= "01100000"; contador <= '1' & x"E"; -- E. al display
when 31 => display <= "01110000"; contador <= '1' & x"F"; -- F. al display
when others => display <= "11111101"; contador <= '0' & x"0";
end case;
end if;

7
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

servomotor <= servo; --salida de la señal PWM hacia el servomotor

servoLED <= servo; --salida de la señal PWM del led testigo

end process ModulPulso; -- fin del proceso

end encoder; -- fin de la arquitectura

--------------------------------------------------------------------------------------------------

##############################################################
# UCF para la Nexys 2 #
##############################################################
# reloj de 50MHz de la nexys2
net "clk" loc ="B8" ; # 50MHz

# reset asíncrono en alto en la nexys2 (BTN0) y en el encoder (Push)

net "resetB" loc ="B18" ; # btn0
net "resetP" loc ="L15" ; # JA1

# señales A y B del encoder

net "A" loc ="M15" ; # JA4
net "B" loc ="L17" ; # JA3

# salida del contador de 5 bits cuando msb=5

net "contador(0)" loc ="J14" ; # LD0
net "contador(1)" loc ="J15" ; # LD1
net "contador(2)" loc ="K15" ; # LD2
net "contador(3)" loc ="K14" ; # LD3
net "contador(4)" loc ="E17" ; # LD4

# salida a display de 7 segmentos + P

net "display(7)" loc ="L18" ; #A
net "display(6)" loc ="F18" ; #B
net "display(5)" loc ="D17" ; #C
net "display(4)" loc ="D16" ; #D
net "display(3)" loc ="G14" ; #E
net "display(2)" loc ="J17" ; #F
net "display(1)" loc ="H14" ; #G
net "display(0)" loc ="C17" ; #P

# salida a los ánodos

net "AN(0)" loc ="F17" ; # AN0
net "AN(1)" loc ="H17" ; # AN1
net "AN(2)" loc ="C18" ; # AN2
net "AN(3)" loc ="F15" ; # AN3

# salidas de pwm para el servomotor y un led testigo

8
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

net "servomotor" loc ="P18" ; # JD4

net "servoLED" loc ="R4" ; # LD7

#Nexys2 Pmod Connector Pin Assignments

#Pmod JA Pmod JB Pmod JC Pmod JD
#JA1:L15 JA7:K13 JB1:M13 JB7:P17 JC1:G15 JC7:H15 JD1:J13 JD7:K14
#JA2:K12 JA8:L16 JB2:R18 JB8:R16 JC2:J16 JC8:F14 JD2:M18 JD8:K15
#JA3:L17 JA9:M14 JB3:R15 JB9:T18 JC3:G13 JC9:G16 JD3:N18 JD9:J15
#JA4:M15 JA10:M16 JB4:T17 JB10:U18 JC4:H16 JC10:J12 JD4:P18 JD10:J14

Esta información se puede consultar en el boletín de la UPIITA números 29 y 34

([Link]).

En la figura 3.5 se muestra el diagrama de conexión, y en la 3.6 fotos del funcionamiento del
código presentado para 3 de las 32 posiciones (3, 2. y F.).

Figura 3.5. Diagrama de conexión para el control de posición de un servomotor.

Figura 3.6. Posiciones del servo con encoder mecánico rotatorio.

Teclado y PS2

Un teclado comercial PS/2 de 104 teclas se encarga del rastreo de teclas, del sistema anti-
rebotes y de la transmisión de datos utilizando una trama perfectamente establecida. El
teclado PS/2 tiene un mapa de teclas a las que asigna un código, de uno o dos bytes, para
cada una de ellas y que son los códigos que nos va a transmitir para indicarnos que se está
pulsando una tecla determinada. A estos códigos se les llama códigos de rastreo de teclado,
mostrados en la figura 3.7.

9
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Figura 3.7. Teclado con los códigos de rastreo.

El teclado PS/2 envía el código de rastreo asociado a una tecla al ser esta pulsada, tantas
veces como sea necesario si se mantiene pulsada con una cadencia tal como indique su tiempo
de repetición, que es programable, y el mismo código de rastreo con el prefijo del byte F0h
al ser soltada, también conocido como Break Code.

Por ejemplo: Para conseguir la letra G Mayúscula debemos pulsar la tecla Shift y mientras la
mantenemos pulsada, pulsar la tecla G, soltar la tecla G y soltar la tecla Shift. Esa secuencia
de pulsaciones nos va a hacer que el teclado transmita la siguiente secuencia de bytes:

Pulsar Shift -> 12h, (scan code de la tecla shift, ver figura 3.8)
Pulsar "G" -> 34h,
Soltar "G" -> F0h 34h
y soltar Shift -> F0h 12h

o escribiendo solo los bytes que vamos a recibir:

12h, 34h, F0h, 34h, F0h, 12h

En la siguiente tabla 3.1 se muestran las letras del abecedario y junto con el código de rastreo
(scan code) y su dato en ASCII.

10
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Tabla 3.1. Abecedario y código de rastreo (scan code)

Character Scan Code (hex) ASCII Character (hex)
A 1C 41
B 32 42
C 21 43
D 23 44
E 24 45
F 2B 46
G 34 47
H 33 48
I 43 49
J 3B 4ª
K 42 4B
L 4B 4C
M 3A 4D
N 31 4E
O 44 4F
P 4D 50
Q 15 51
R 2D 52
S 1B 53
T 2C 54
U 3C 55
V 2A 56
W 1D 57
X 22 58
Y 35 59
Z 1A 5ª

Un teclado PS2 también permite comandos, que por el momento no se presentarán en este
documento y cuya información está disponible en libros y en la red.

Conexionado eléctrico:

El teclado PS/2 se conecta mediante cuatro hilos. Dos de ellos son para alimentación Vcc a
5V y GND, y otros dos para las señales Data y Clock. El pinout de los conectores Mini-DIN
PS/2 tanto hembra (en la PC), como machos (en el teclado) se muestran en la figura 3.8 y en
la tabla 3.2.

11
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Tabla 3.2. Asignación de pines y su

descripción.
Pin Nombre Dirección Descripción
1 DATA ↔ Pin de dato serial
2 N/C No conectado
3 GND − Tierra
4 VCC → Alimentación
Figura 3.8. Conexionado del PS2. 5 CLK → Reloj
6 N/C No conectado

En el Teclado PS/2 las señales Data y Clock son de "colector abierto". Esto quiere decir que
para establecer una comunicación eléctricamente correcta debemos nosotros suministrar
voltaje para el nivel lógico alto, y es él el encargado de dar los correspondientes niveles
lógicos bajos, tirando nuestra señal a GND cuando así sea necesario. Este tema se soluciona
conectando dos resistencias de 10K entre dichas líneas y Vcc por lo que siempre tendrán
nivel lógico alto, salvo cuando el teclado disponga lo contrario y lo tire a GND para dar lo
correspondientes niveles lógicos bajos. Esto es lo que se llama conectar unas resistencias
Pull-Up.

En la figura 3.9 se muestra como conectar las resistencias Pull-Up entre el teclado y el
dispositivo programable.

Figura 3.9. Conexión con resistencias de Pull-up.

Protocolo de comunicación PS/2:

El teclado PS/2 se comunica mediante un Protocolo Serie Síncrono, utiliza una señal de Clock
que índica cuando están disponibles los correspondientes bits en la señal de Data.

En reposo la señal de Clock está a nivel alto; a cada pulso a nivel bajo corresponde un pulso
a nivel alto o bajo en la señal de Data, que se traducen respectivamente como bits 0 ó 1 del
dato a transmitir.

La trama completa se compone de 11 bits. Siendo el primero un bit de Start, a continuación,

los 8 bits del Dato a transmitir enviándose primero el LSB (ó bit menos significativo), el
décimo es el de paridad (usa la Impar, u Odd en inglés) y por último un bit de ACK o Stop,

12
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

como puede verse en la figur 3.10 el cronograma de esta trama de comunicación PS/2
Teclado (Keyboard) -> PC (host):

Figura 3.10. Trama de comunicación del teclado al host.

El teclado PS/2 admite también comandos enviados desde el PC con el mismo formato, el
protocolo es bidireccional, el cual se indica mediante la señal de Clock al colocarla en nivel
bajo durante 160 uS, y la señal de Data a bajo unos 35 uS después de del Clock. Posteriomente
se espera la señal del Clock generada por el Teclado. Esto indica que el teclado está dispuesto
para recibir nuestro comando. Después de detectar el primer pulso de Clock, a partir del
siguiente se comienza a enviar el byte (los 8 bits de comando) con el correspondiente pulso
en bajo, iniciando por el LSB, y después el bit de paridad impar (el número de unos en los
datos más el de paridad deber ser impar, o sea 1 si el número de unos es par y cero si el total
de unos es impar). Por último, hay que esperar el nivel bajo de ACK del teclado, tras dos
pulsos de reloj, mostrado en la figura 3.11.

Figura 3.11. Trama de comunicación del host al teclado.

A continuación, se muestran tres códigos para el teclado PS2 escritos en VHDL, que utilizan
ciclos for con estructura de registro de corrimiento y con FSM.

------------------------------------------------------------------------------------------------
-- Primer código basado en un registro de corrimiento
------------------------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.all;

Entity Reg_Der_S_P is
generic (n: in integer:= 33); --Trabaja a 11x3 para asegurar que no haya perdida de datos
port (CLK_T: in std_logic; --reloj del ps2
RST : in std_logic; --reset
R : in std_logic; --dato del ps2
Q : out std_logic_vector (8 downto 1)); --salida
endReg_Der_S_P;

13
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Architecture Registro of Reg_Der_S_P is

signal Qn, Qp: std_logic_vector (n-1 downto 0);
begin

Combinacional: process (Qp,R)

Begin
Qn(n-1) <= R;
For i in n-2 downto 0 loop
Qn(i) <= Qp(i+1);
end loop;
Q <= Qn(8 downto 1);
end process Combinacional;

Secuencial: process (CLK_T,RST)

Begin
if (RST = '1') then Qp<= (others => '0'); -- Reset manda 0 a todas las salidas
elsif (CLK_T'event and CLK_T = '1') then Qp<=Qn; -- se revisa si hay flanco de subida
end if;
end process Secuencial;
end Registro;
-- asignaciones de variables
--Qn(0) <= start
--Qn(8) ->Qn (1) <= Data
--Qn(9) <= Parity
--Qn(10) <= Stop

------------------------------------------------------------------------------------------------
-- Segundo código
------------------------------------------------------------------------------------------------
-- Código de teclado PS2 implementado con FSM
-- teclado con PS2
-- se toma la lectura al presionar una tecla empleando una FSM
-- [Link]
-- ps-2-interfacing-with-spartan-3e-webserver

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

--declaración de la entidad
entity key is
port( ps2data: in std_logic; --dato del PS2
ps2clk: in std_logic; --reloj del PS2
leds : out std_logic_vector(7 downto 0); --salida a leds
D: out std_logic_vector(7 downto 0); --salida a display

14
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

anodos: out std_logic_vector (1 to 4)); --habilitación de los ánodos

end key;

--declaración de la arquitectura con FSM

architecture keyboard of key is
type state is (state1,state2,state3,state4,state5,state6,state7,state8,state9,state10,state11);
signal EP,EF : state; --EP=estado presente, EF=estado futuro
signal store : std_logic_vector(7 downto 0):="00000000"; --señal para guardar el dato
signal start,parity,stop : std_logic; --bit de inicio, bit de paridad y bit de paro
begin

--proceso para la lectura de los datos del teclado por el PS2

process(ps2clk,ps2data)
begin
--actualización del estado presenteef
if ps2clk'event and ps2clk = '1' then EP <= EF;
end if;
--guardado de datos
if ps2clk'event and ps2clk = '0' then
if EP = state1 then start <= ps2data; EF <= state2;
elsif EP = state2 then store(0) <= ps2data; EF <= state3;
elsif EP = state3 then store(1) <= ps2data; EF <= state4;
elsif EP = state4 then store(2) <= ps2data; EF <= state5;
elsif EP = state5 then store(3) <= ps2data; EF <= state6;
elsif EP = state6 then store(4) <= ps2data; EF <= state7;
elsif EP = state7 then store(5) <= ps2data; EF <= state8;
elsif EP = state8 then store(6) <= ps2data; EF <= state9;
elsif EP = state9 then store(7) <= ps2data; EF <= state10;
elsif EP = state10 then parity <= ps2data; EF <= state11;
elsif EP = state11 then stop <= ps2data; EF <= state1;
end if;
end if;
end process; --termina de leer los datos del teclado

--proceso para mandar el dato leido a leds

process(store)
begin
leds <= store;
end process; --termina el envío de datos a leds

--proceso para visualizar el dato en el display de la nexys2

process(store)
begin
anodos <= "1110";
--asigna al display el dato del teclado guardado en la variable store
-- abcdefgP
if store = X"16" then D <= "10011111"; -- 1

15
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

elsif store = X"1E" then D <= "00100101"; -- 2

elsif store = X"26" then D <= "00001101"; -- 3
elsif store = X"25" then D <= "10011001"; -- 4
elsif store = X"2E" then D <= "01001001"; -- 5
elsif store = X"36" then D <= "01000001"; -- 6
elsif store = X"3D" then D <= "00011111"; -- 7
elsif store = X"3E" then D <= "00000000"; -- 8
elsif store = X"46" then D <= "00011001"; -- 9
elsif store = X"45" then D <= "00000011"; -- 0
elsif store = X"4E" then D <= "10111111"; -- '
elsif store = X"55" then D <= "10100101"; -- ¿
elsif store = X"15" then D <= "00000010"; -- q primer linea de letras
elsif store = X"1D" then D <= "11111101"; -- w
elsif store = X"24" then D <= "01100001"; -- e
elsif store = X"2D" then D <= "11110101"; -- r
elsif store = X"2C" then D <= "11100001"; -- t
elsif store = X"35" then D <= "10001001"; -- y
elsif store = X"3C" then D <= "11000111"; -- u
elsif store = X"43" then D <= "11011111"; -- i
elsif store = X"44" then D <= "11000101"; -- o
elsif store = X"4D" then D <= "00110001"; -- p
elsif store = X"54" then D <= "10111111"; -- ´
elsif store = X"5B" then D <= "11111101"; -- +
elsif store = X"1C" then D <= "00010001"; -- a segunda linea de letras
elsif store = X"1B" then D <= "01001001"; -- s
elsif store = X"23" then D <= "10000101"; -- d
elsif store = X"2B" then D <= "01110001"; -- f
elsif store = X"34" then D <= "00001001"; -- g
elsif store = X"33" then D <= "10010001"; -- h
elsif store = X"3B" then D <= "10000111"; -- j
elsif store = X"42" then D <= "11111101"; -- k
elsif store = X"4B" then D <= "11100011"; -- l
elsif store = X"4C" then D <= "01010101"; -- ñ
elsif store = X"52" then D <= "01100011"; -- {
elsif store = X"5D" then D <= "00001111"; -- }
elsif store = X"1A" then D <= "11111101"; -- z tercer linea de letras
elsif store = X"22" then D <= "11111101"; -- x
elsif store = X"21" then D <= "11100101"; -- c
elsif store = X"2A" then D <= "11111101"; -- v
elsif store = X"32" then D <= "11000001"; -- b
elsif store = X"31" then D <= "11010101"; -- n
elsif store = X"2A" then D <= "11111111"; -- m
elsif store = X"41" then D <= "11111111"; -- ,
elsif store = X"49" then D <= "11111110"; -- .
elsif store = X"4A" then D <= "11111101"; -- -
-- elsif store = "" then D <= ""; --
else D <= X"FF"; -- APAGA LOS DISPLAY

16
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

end if;
end process; --termina de leer los datos del teclado

end keyboard; --termina la arquitectura

------------------------------------------------------------------------------------------------
-- Tercer código
------------------------------------------------------------------------------------------------
-- Lectura del código de rastreo de un teclado conectado al puerto PS/2 de la Nexys 2
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

--Señales de la entidad
--reloj y dato del PS2, reset con un interruptor SW0 o botón
--8 leds de la tarjeta para sacar el código hexadecimal asignado a cada tecla
entity teclado is
Port ( clk,dato,rst: in std_logic;
leds : out std_logic_vector(7 downto 0));
end teclado;

architecture Arq_teclado of teclado is

--se declaran las señales reg, que es un registro de 22 bits
--para recibir los codigos de rastreo al soltar la tecla
--y tmp que se utiliza como un contador hasta 22 (0 a 21)
signal reg: std_logic_vector(21 downto 0);
signal tmp: std_logic_vector(4 downto 0);
begin

--Proceso para guardar los datos enviados del teclado

--por medio de un registro de corrimiento a la derecha
process (clk,rst,dato,reg)
begin
if rst='1' then reg <= (others=>'0');
elsif clk'event and clk ='0' then reg <= dato & reg(21 downto 1);
end if;
end process;

--Proceso que habilita el contador tmp para la recepción del dato del teclado
conteo:process (clk,rst,tmp)
begin
--si reset = '1' o tmp=22, se resetea la señal tmp (contador)
if rst='1' or tmp = "10110" then tmp <= (others=>'0');
--se habilita el contador con flanco de subida del reloj
elsif clk'event and clk ='1' then tmp <= tmp + 1;

17
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

end if;
end process conteo;

--Proceso para la salida de datos a los leds

led:process (rst,reg,tmp)
begin
if rst='1' then leds <= (others=>'0');
--se verifica que ya se hayan mandado los 22 números de trama al soltar la tecla
elsif tmp = "10110" then
--al soltar la tecla se envía el código de rastreo F0 "break code" y el codigo de la tecla
elsif reg(8 downto 1)= X"F0" then leds <= reg(19 downto 12);
else leds <= (others=>'0');
end if;
end process led;
end Arq_teclado;

“Si tienes alguna duda, apóyate con tu profesor”

Desarrollo.
Procedure

Recuerde MOSTRAR sus circuitos funcionando a su profesor para la valoración del trabajo
de laboratorio (TL2).

1. Implement in TLD a pulse counter in high in ms with output to display, which when
pressing a button (push) the count is displayed on the display and when the button is
released it stops at a value, but if it is pressed again continue the count. It has a reset
button to restart at zero any time it is pressed. The display can count to a maximum of
9,999 ms (9.9 s) and when this value is reached it will stop and a message (“maximum
value”, “I am already filled”) will sound in a speaker, etc. By means of a RGB led it is
indicated in what rank the count is (0 < R  3,333, 3,333 < G  6,666, 6,666 < B 
9,999). Each time the range is changed, a “BEEP” will sound in a buzer or speaker.
The block diagram is shown in figure 3.12, an example of the operation in figure 3.13
and one way to implement the TLD in figure 3.14. The language in which it is
implemented is defined by the teacher. Report the commented codes (vhd,v,ucf,vxdc,csv),
simulations, operation photos with explanatory text of what happens.

Figura 3.12. Esquema para el medidor de ms.

18
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Figura 3.13. Ejemplo de funcionamiento cuando se presiona 3 veces 100ms.

Figura 3.14. Estructura de bloques para el medidor de ms en TLD.

Consultar el boletín UPIITA número 63 ([Link] o

[Link]
numero-63).

2. Implement a position control for a servo motor with stop by changing the control signal
(PWM) suitable to the motor type, by means of a mechanical rotary encoder (optical or
magnetic), shown in figure 3.15. The movement of the encoder in one direction will
change the position of the servo in that same direction, both clockwise and
counterclockwise. The displays (see figure 3.16) indicate the angle of the motor (0°-
180°), with a minimum resolution of 5°. The engine must carry a load on the axle (belt,
wheels, pulley, animatronic system, window or door to scale, etc., simple things such as
propellers, clips, wires, links, sheets of paper, etc. are not allowed). The language in
which it is implemented is defined by the teacher. Report the commented codes,
simulations, operation photos with explanatory text of what happens.

Figura 3.15. Diagrama a bloques para el control de posición del servo por PWM.

19
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Figura 3.16. Ejemplo del valor del display para el servo con tope.

3. Realizar sus comentarios y conclusiones (incluir en por lo menos un párrafo Gracias

“Gracias a esta práctica…”). Todos los códigos van en una sola columna con
comentarios editados para que no brinquen de renglón y no van en imagen.
Write your comments and conclutions. All the codes are written in one column with
comments, only text, not images.

NOTA: Respetar la numeración de cada punto de este formato en el reporte escrito [máximo
25 cuartillas si se entrega impreso (Letra Times New Roman de 12ptos, interlineado
sencillo)].

Revisar el siguiente Código e indicar para que sirve:

Review the next code and say what is it for:

------------------------------------------------------------------------------------------
-- Contador ascendente y descendente, con 2 reset asíncronos y salida pwm a led.

Library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;

-- Declaración de la entidad
entity Contador is
Port (UpDown: in STD_LOGIC_VECTOR(1 DOWNTO 0); -- botones subir y bajar ms
CLK: in STD_LOGIC; -- reloj de 50MHz-nexys 2 y 100MHz-nexys 3
RESET: in STD_LOGIC; -- reset
SALED: OUT STD_LOGIC; -- salida del led testigo
DISPLAY: out STD_LOGIC_VECTOR(7 DOWNTO 0); -- segmentos "abcdefgP"
AN: out STD_LOGIC_VECTOR(3 DOWNTO 0); -- ánodos del display
RGB: out STD_LOGIC_VECTOR(1 TO 3)); -- salida a leds RGB para el rango
end Contador;

-- Declaración de la arquitectura
architecture Behavioral of Contador is

20
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

-- Declaración de señales de los divisores

signal Conta_500us: integer range 1 to 25_000:=1; -- uso en el pulso de 1ms
-- para la nexys 2 25000, si se usa la nexys 3 cambiar a 50000.
signal contadors: integer range 1 to 6_250:=1; -- pulso1 de 0.25ms
-- para la nexys 2 6250, si se usa la nexys 3 cambiar a 12500
signal SAL_1ms,SAL_250us: std_logic; --igual que pulso y pulso1, respectivamente

-- Declaración de señales de los contadores

signal CONT: std_logic_vector (15 DOWNTO 0):=(others=>'0'); -- 16 bits (proc. conteo)
SIGNAL CONT2: INTEGER; -- cambia cont de 16 bits a entero (proc. conteo)

-- Declaración de señales de la asignación de U-D-C-UM

signal P: std_logic_vector (15 DOWNTO 0); -- asigna UNI, DEC, CEN, MIL
signal UNI,DEC,CEN,MIL: std_logic_vector (3 DOWNTO 0); -- digitos unidades, decenas,
-- centenas y unidad de millar

-- Declaración de señales de la multiplexación y asignación de U-D-C-UM al display

signal SEL: std_logic_vector (1 downto 0):="00"; -- selector de barrido
signal D: std_logic_vector (3 downto 0); -- sirve para almacenar los valores del display

-- Declaración de señales de la base de tiempo

SIGNAL PERIOD: INTEGER RANGE 0 TO 2499:=0; -- periodo de 2.5 segundos @ PWM

BEGIN

---------------------DIVISOR 1ms------------------------------------
-- en este proceso se genera una señal "SAL_1ms" de 1ms de periodo
PROCESS(reset, CLK)
begin
if reset ='1' then
Conta_500us <= 1; -- se reinicializa
elsif(CLK'event and CLK='1') THEN
if(Conta_500us = 25_000) then -- pregunta si ya se alcanzó 0.5ms (nexys2)
--if(Conta_500us = 50000) then -- pregunta si ya se alcanzó 0.5ms (nexys3)
SAL_1ms <= not SAL_1ms; --se genera 0.5ms en bajo y 0.5ms en alto
Conta_500us <= 1; --reinicia el Contador a 1
else
Conta_500us <= Conta_500us + 1;
end if;
end if;
end process; --termina el proceso de generación de señal 1ms

--------------------------------CONTEO-----------------------------------
-- con Up se incrementa y Down decrementa en el rango 0<CONT<9999

21
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

PROCESS(RESET, SAL_1ms, UpDown, CONT)

begin
if RESET='1' then
CONT<=(others=>'0');
else
if(SAL_1ms'EVENT and SAL_1ms='1') then -- reloj SAL de 1ms
if UpDown="01" then -- decrementa (Down)
if(CONT=x"0000") then -- compara contra 0
CONT<=CONT; -- si llegó a cero mantiene el cero
else
CONT<=CONT-'1'; -- sino decrementa
end if;
elsIF UpDown="10" then --incrementa
if(CONT >= "0010011100001111") then -- compara vs 9,999
-- (270F hex)
CONT<=CONT; -- si llego a 9999 mantiene 9999
else
CONT<=CONT+'1'; -- sino incrementa
end if;
else --cubre UpDown="00" e UpDown="11"
CONT<=CONT;
end if;
end if;
end if;

CONT2<=CONV_INTEGER(CONT); --se convierte CONT a entero

end process;

--------------------------------RGB-----------------------------------
-- 0< R <3333 3333< G <6666 6666< B <9999
PROCESS(CONT2)
begin
if CONT2>=0 and CONT2 <= 3333 then RGB <="100"; -- 0< R <3333
elsif CONT2>3333 and CONT2 <= 6666 then RGB <="010"; -- 3333< G <6666
elsif CONT2>6666 and CONT2 <= 9999 then RGB <="001"; -- 6666< B <9999
else RGB <="000"; -- apaga todos
end if;
end process;

--------------------PWM CONTROLADO POR CONTADOR DE ms/4------------------------

PROCESS (RESET, SAL_1ms, PERIOD)

BEGIN
if (RESET='1' OR PERIOD >= 2499) then --9999="0010011100001111"

22
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

PERIOD <= 0; --(others=>'0');

elsif (SAL_1ms'EVENT and SAL_1ms='1') then -- reloj SAL_1ms de 1ms
PERIOD <= PERIOD + 1;
if (PERIOD <= CONT2/4) then SALED <='1'; -- Salida a led testigo t/4
-- if (PERIOD <= CONT) then SALED <='1'; -- Salida a led testigo
else SALED <='0';
end if;
end if;
end PROCESS; --fin del proceso PWM

-----------CONVERTIR DE BIN A BCD------------------

-- Este proceso contiene un algoritmo recorre y suma 3 para convertir un número binario a
-- bcd, que se manda a los displays.
-- El algoritmo consiste en desplazar (shift) el vector inicial (en binario) el número de veces
-- según sea el número de bits. Cuando alguno de los bloques de 4 bits (U-D-C-UM) sea igual
-- o mayor a 5 (por eso el >4) se le debe sumar 3 a ese bloque, después se continua
-- desplazando hasta que cualquier otro bloque cumpla con esa condición y se le sumen 3.
-- Inicialmente se rota 3 veces porque es el número mínimo de bits que debe tener para que
-- sea igual o mayor a 5.
-- Finalmente se asigna a otro vector, el vector ya convertido, que cuenta con 4 bloques para
-- las 4 cifras de 4 bits cada una.

PROCESS(CONT)
VARIABLE UM_C_D_U:STD_LOGIC_VECTOR(29 DOWNTO 0);
--30 bits para separar las Unidad_de_Millar-Centenas-Decenas-Unidades
BEGIN

--ciclo de inicialización
FOR I IN 0 TO 29 LOOP --
UM_C_D_U(I):='0'; -- se inicializa con 0
END LOOP;

UM_C_D_U(13 DOWNTO 0):=CONT(13 downto 0); --contador de 14 bits

-- UM_C_D_U(17 DOWNTO 4):=CONT(13 downto 0); --contador de 14 bits, carga desde
-- el shift4
--ciclo de asignación UM-C-D-U
FOR I IN 0 TO 13 LOOP
-- FOR I IN 0 TO 9 LOOP -- si carga desde shift4 solo hace 10 veces el ciclo shift add
-- los siguientes condicionantes comparan (>=5) y suman 3
IF UM_C_D_U(17 DOWNTO 14) > 4 THEN -- U
UM_C_D_U(17 DOWNTO 14):= UM_C_D_U(17 DOWNTO 14)+3;
END IF;

IF UM_C_D_U(21 DOWNTO 18) > 4 THEN -- D

UM_C_D_U(21 DOWNTO 18):= UM_C_D_U(21 DOWNTO 18)+3;
END IF;

23
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

IF UM_C_D_U(25 DOWNTO 22) > 4 THEN -- C

UM_C_D_U(25 DOWNTO 22):= UM_C_D_U(25 DOWNTO 22)+3;
END IF;

IF UM_C_D_U(29 DOWNTO 26) > 4 THEN -- UM

UM_C_D_U(29 DOWNTO 26):= UM_C_D_U(29 DOWNTO 26)+3;
END IF;
-- realiza el corrimiento
UM_C_D_U(29 DOWNTO 1):= UM_C_D_U(28 DOWNTO 0);

END LOOP;

P<=UM_C_D_U(29 DOWNTO 14); -- guarda en P y en seguida se separan UM-C-D-U

END PROCESS;

--UNIDADES
UNI<=P(3 DOWNTO 0);
--DECENAS
DEC<=P(7 DOWNTO 4);
--CENTENAS
CEN<=P(11 DOWNTO 8);
--MILLARES
MIL<=P(15 DOWNTO 12);

-------------------DIVISOR ÁNODOS-------------------

process (CLK) begin

if rising_edge(CLK) then
if (contadors = 6250) then --cuenta 0.125ms (50MHz=6250)
-- if (contadors = 12500) then --cuenta 0.125ms (100MHz=12500)
SAL_250us <= NOT(SAL_250us); --genera un barrido de 0.25ms
contadors <= 1;
else
contadors <= contadors+1;
end if;
end if;
end process; -- fin del proceso Divisor Ánodos

--------------------MULTIPLEXOR---------------------

PROCESS(SAL_250us, sel, UNI, DEC,CEN, MIL)

BEGIN
IF SAL_250us'EVENT and SAL_250us='1' THEN SEL <= SEL+'1';

24
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

CASE(SEL) IS
when "00" => AN <="0111";D <= UNI; -- UNIDADES
when "01" => AN <="1011";D <= DEC; -- DECENAS
when "10" => AN <="1101";D <= CEN; -- CENTENAS
when "11" => AN <="1110";D <= MIL; -- UNIDAD DE MILLAR
when OTHERS=>AN <="1110"; D <= MIL; -- UNIDAD DE MILLAR
END CASE;

end if;

END PROCESS; -- fin del proceso Multiplexor

--------------------DISPLAY---------------------

PROCESS(D)
Begin
case(D) is -- abcdefgP
WHEN "0000" => DISPLAY <= "00000011"; --0
WHEN "0001" => DISPLAY <= "10011111"; --1
WHEN "0010" => DISPLAY <= "00100101"; --2
WHEN "0011" => DISPLAY <= "00001101"; --3
WHEN "0100" => DISPLAY <= "10011001"; --4
WHEN "0101" => DISPLAY <= "01001001"; --5
WHEN "0110" => DISPLAY <= "01000001"; --6
WHEN "0111" => DISPLAY <= "00011111"; --7
WHEN "1000" => DISPLAY <= "00000001"; --8
WHEN "1001" => DISPLAY <= "00001001"; --9
WHEN OTHERS => DISPLAY <= "11111111"; --apagado
END CASE;
END PROCESS; -- fin del proceso Display

------------------------------------------------

end Behavioral; -- fin de la arquitectura

///////////////////////////////////////////////////////////////////////////////////////
// Archivo de restricciones de usuario (UCF) Nexys 2 //
///////////////////////////////////////////////////////////////////////////////////////
//CLK reloj 50MHz
NET "CLK" LOC = "B8";

//DISPLAYS
NET "DISPLAY(7)" LOC = "L18"; // a
NET "DISPLAY(6)" LOC = "F18"; // b

25
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

NET "DISPLAY(5)" LOC = "D17"; // c

NET "DISPLAY(4)" LOC = "D16"; // d
NET "DISPLAY(3)" LOC = "G14"; // e
NET "DISPLAY(2)" LOC = "J17"; // f
NET "DISPLAY(1)" LOC = "H14"; // g
NET "DISPLAY(0)" LOC = "C17"; // P

//ANODOS
NET "AN(3)" LOC = "F17"; // AN0
NET "AN(2)" LOC = "H17"; // AN1
NET "AN(1)" LOC = "C18"; // AN2
NET "AN(0)" LOC = "F15"; // AN3

//UpDown,RESET--PUSH BUTTON
NET "UpDown(1)" LOC = "B18"; // btn0 SUBE
NET "UpDown(0)" LOC = "D18"; // btn1 BAJA
NET "RESET" LOC = "H13”; // btn2 RST

//SALED salida a led testigo

NET "SALED" LOC = "J14"; // LD0

//RGB salida a leds de rango

NET "RGB(1)" LOC = "M15"; // JA4
NET "RGB(2)" LOC = "T17"; // JB4
NET "RGB(3)" LOC = "H16"; // JC4

#Nexys2 Pmod Connector Pin Assignments

#Pmod JA Pmod JB Pmod JC Pmod JD
#JA1:L15 JA7:K13 JB1:M13 JB7:P17 JC1:G15 JC7:H15 JD1:J13 JD7:K14
#JA2:K12 JA8:L16 JB2:R18 JB8:R16 JC2:J16 JC8:F14 JD2:M18 JD8:K15
#JA3:L17 JA9:M14 JB3:R15 JB9:T18 JC3:G13 JC9:G16 JD3: N18 JD9:J15
#JA4:M15 JA10:M16 JB4:T17 JB10:U18 JC4:H16 JC10:J12 JD4:P18 JD10:J14

"Imprime la parte UPIITA a tu trabajo, busca información en la red y compártela

con tus compañeros".

“Intercambia opiniones y experiencias con tus compañeros de grupo, acerca del

conocimiento que has adquirido después de haber finalizado la práctica.”

Referencias.
References.

Referencias consultadas en enero-2020:

Teclado de computadora, [Link]
Código y diagrama de envío, [Link]

26
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Juan Antonio Jaramillo Gómez, Mirna Salmerón Guzmán, Rafael Santiago Godoy,
CONTROL DE POSICIÓN DE UN SERVOMOTOR UTILIZANDO LA TARJETA DE
DESARROLLO NEXYS 2 Y VHDL, boletín UPIITA número 29, consultado en enero-2020,
disponible en [Link]
control-de-posicion-de-un-servomotor-utilizando-la-tarjeta-de-desarrollo-nexys-2-y-vhdl

Juan Antonio Jaramillo Gómez, Mirna Salmerón Guzmán, Rafael Santiago Godoy,
CONTROL DE UN SERVOMOTOR CON UN ENCODER MECÁNICO ROTATORIO
UTILIZANDO VHDL Y LA NEXYS II, boletín UPIITA número 34, consultado en enero-
2020, disponible en [Link]
34/122-control-de-un-servomotor-con-un-coder-mecanico-rotatorio-utilizando-vhdl-y-la-
nexys-ii

Juan Antonio Jaramillo Gómez, Mirna Salmerón Guzmán, Brahim El Filali, Método de
Conversión de Binario a BCD con VHDL, boletín UPIITA número 63, consultado en enero-
2020, disponible en [Link]
63/1434-metodo-de-conversion-de-binario-a-bcd-con-vhdl

PWM, consultado en enero-2020, disponible en

[Link]

Tutorial Verilog, con sultado en enero-2020, disponible en:

[Link]

27