UNIVERSIDAD DE EL SALVADOR | FACULTAD DE INGENIERIA Y

ARQUITECTURA

RELOJ DIGITAL EN
VHDL
CATEDRÁTICO: Ing. Salvador German
INSTRUCTOR: Juan Albiñana

PRESENTADO POR:
Cruz Pérez, Francisco Javier CP09042
Segovia Salazar, Mario Alejandro SS12008

FECHA DE ENTREGA: Miércoles 18 de junio de 2014

 Índice
Introducción............................................................................................................................3
Objetivos.................................................................................................................................4
Marco Teórico.........................................................................................................................5
Desarrollo de Circuitos............................................................................................................7
Flip Flop JK Con Entradas Reset y Set..................................................................................7
Flip-flop RS con entradas adicionales SET y RESET...........................................................11
Flip-flop D con entradas SET y RESET................................................................................14
Contador síncrono UP/DOWN MOD 10............................................................................18
Flip-flop T con entradas SET y RESET................................................................................22
Reloj Digital.......................................................................................................................25
Investigación.........................................................................................................................30
¿Qué es un duty cicle?......................................................................................................30
Investigue las librerías de ALTERA, que permiten usar flip-flop ya diseñados, escriba el
código necesario para usar estos componentes..............................................................31
Investigue algunas formas de crear un tren de pulsos.....................................................32
¿Es posible generar con un 555 un tren de pulsos con Duty-Cicle de 50%?....................33
Conclusiones.........................................................................................................................35
Bibliografía............................................................................................................................36
Introducción

Hasta el momento, las actividades que se han venido presentado durante este tiempo,
han sido la aplicación de los sistemas digitales combinacionales. Se entiende lo anterior
como un dispositivo que reacciona solamente a sus puertas de entrada, hemos realizado
diversos circuitos que involucran los mismos; por ejemplo los clásicos de convertidores
BCD, los multiplexores, demultiplexores, codificadores, mostrar en un display de 7
segmentos el numero decimal correspondiente a su binario natural; entre otros. Todos los
anteriores se han analizado en función de sus salidas y solamente de esa forman se
pueden analizar. Ahora, introducimos un nuevo tipo de circuito, el cual lleva un análisis
muy diferente; que son los circuitos secuenciales. Estos, dependen no solo de sus entradas
de datos; sino que también de las salidas de ellos mismos o de otros sub elementos que
integra un circuito determinado. La aplicación de ellos son diversos, no bastara tan solo
ejemplificar los circuitos básicos en este reporte; basta con decir que los circuitos
secuenciales lo rodean los flip-flops. Por la naturaleza humana y su variedad de ideas, se
han creado diversos tipos de flip flops, para poder dar abasto a la creatividad del
diseñador de sistemas digitales. Y es obvio aceptar la idea que la aplicación tiene como
límite la imaginación humana. Aquí se presentan simulaciones de distintos flip-flops;
también se introducen los contadores y un ejercicio de aplicación diversa; que es la
creación de un reloj digital; basándonos en esta idea y aplicando los funcionamientos de
estos dispositivos para poder dar solución a los problemas planteados.

4
Objetivos

 Simular los distintos circuitos secuenciales base en TINA, nos referimos a los tipos
de flip flops más importantes.
 Analizar los flip flops y dar conclusiones sobre su funcionamiento.
 Utilizar de una manera eficiente las particularidades de cada flip flop y usar sus
fortalezas de funcionamiento para dar solución a los problemas planteados.
 Responder de una manera deductiva y basándonos en las experimentaciones de la
simulación de los circuitos planteados; preguntas de razonamiento que nos
ayudara a comprender de manera eficiente las cualidades de estos dispositivos,
 Saber diferenciar los tipos de circuitos vistos hasta ahora (combinacional,
secuencial) y saber responder cuando se ocupara cada uno y en que circunstancia.

5
Marco Teórico

A diferencia de los sistemas combinacionales, en los sistemas secuenciales, los valores de

las salidas, en un momento dado, no dependen exclusivamente de los valores de las
entradas en dicho momento, sino también dependen del estado anterior o estado interno.
El sistema secuencial más simple es el biestable, de los cuales, el de tipo D (o cerrojo) es el
más utilizado actualmente. La mayoría de los sistemas secuenciales están gobernados por
señales de reloj. A éstos se los denomina "síncronos" o "sincrónicos", a diferencia de los
"asíncronos" o "asincrónicos" que son aquellos que no son controlados por señales de
reloj.
A continuación se indican los principales sistemas secuenciales que pueden encontrarse
en forma de circuito integrado o como estructuras en sistemas programados:

 Contador
 Registros
FLIP FLOPS
Un biestable (flip-flop en inglés), es un multivibrador capaz de permanecer en uno de dos
estados posibles durante un tiempo indefinido en ausencia de perturbaciones.1 Esta
característica es ampliamente utilizada en electrónica digital para memorizar información.
El paso de un estado a otro se realiza variando sus entradas. Dependiendo del tipo de
dichas entradas los biestables se dividen en:

 Asíncronos: sólo tienen entradas de control. El más empleado es el biestable RS.

 Síncronos: además de las entradas de control posee una entrada de sincronismo o
de reloj.

Si las entradas de control dependen de la de sincronismo se denominan síncronas y en

caso contrario asíncronas. Por lo general, las entradas de control asíncronas prevalecen
sobre las síncronas. La entrada de sincronismo puede ser activada por nivel (alto o bajo) o
por flanco (de subida o de bajada). Dentro de los biestables síncronos activados por nivel
están los tipos RS y D, y dentro de los activos por flancos los tipos JK, T y D. Los biestables
síncronos activos por flanco (flip-flop) se crearon para eliminar las deficiencias de los
latches (biestables asíncronos o sincronizados por nivel).

6
Un biestable puede usarse para almacenar un bit. La información contenida en muchos
biestables puede representar el estado de un secuenciador, el valor de un contador, un
carácter ASCII en la memoria de un ordenador, o cualquier otra clase de información. Un
uso corriente es el diseño de máquinas de estado finitas electrónicas. Los biestables
almacenan el estado previo de la máquina que se usa para calcular el siguiente.
El T es útil para contar. Una señal repetitiva en la entrada de reloj hace que el biestable
cambie de estado por cada transición alto-bajo si su entrada T está a nivel 1. La salida de
un biestable puede conectarse a la entrada de reloj de la siguiente y así sucesivamente. La
salida final del conjunto considerado como una cadena de salidas de todos los biestables
es el conteo en código binario del número de ciclos en la primera entrada de reloj hasta
un máximo de 2n-1, donde n es el número de biestables usados. Uno de los problemas
con esta configuración de contador (ripple counter en inglés) es que la salida es
momentáneamente inválida mientras los cambios se propagan por la cadena justo
después de un flanco de reloj. Hay dos soluciones a este problema. La primera es
muestrear la salida sólo cuando se sabe que esta es válida. La segunda, más compleja y
ampliamente usada, es utilizar un tipo diferente de contador síncrono, que tiene una
lógica más compleja para asegurar que todas las salidas cambian en el mismo momento
predeterminado, aunque el precio a pagar es la reducción de la frecuencia máxima a la
que puede funcionar.
Una cadena de biestables T como la descrita anteriormente también sirve para la división
de la frecuencia de entrada entre 2n, donde n es el número de biestables entre la entrada
y la última salida. Los biestables síncronos son propensos a sufrir un problema
denominado metaestabilidad, que ocurre cuando una entrada de datos o de control está
cambiando en el momento en el que llega un flanco de reloj. El resultado es que la salida
puede comportarse de forma imprevista, tardando muchas veces más de lo normal en
estabilizarse al estado correcto, o incluso podría oscilar repetidas veces hasta terminar en
su estado estable. En un ordenador esto puede suponer la corrupción de datos o causar
un fallo de programa.

7
Desarrollo de Circuitos

Antes de empezar el desarrollo de los circuitos propuestos, cabe mencionar que hasta
este punto, sería un poco redundante explicar los pasos específicos a realizarse en el
software TINA. Tres tareas han sido suficientes y hemos comprendido los aspectos
básicos, por lo que para este último reporte que concierne a la materia Sistemas Digitales
solo haremos mención de lo que se hará y lo que se ocupara, damos como versado al
lector el conocimiento del manejo de TINA por lo que le será de fácil entendimiento los
pasos intermedios que no se presentaran aquí.

Flip Flop JK Con Entradas Reset y Set

Para este circuito, tomaremos como referencia el documento entregado en clases, con las
diferentes tablas de excitación y entrada. Específicamente hablando, a continuación
presentamos las tablas que describen el comportamiento del flip flop JK:

FLIP - FLOP "JK"

Tabla de excitación Tabla de entrada
CLK J K Q* Q Q* J K
0 X X Q 0 0 0 X
1 0 0 Q 0 1 1 X
1 0 1 0 1 0 X 1
1 1 0 1 1 1 X 0
1 1 1  Q́

Basándonos en lo anterior, podemos crear un código en VHDL, para poder simular el

comportamiento de este flip flop. Se hacen uso de librerías 1, para poder crear más
fácilmente nuestro circuito. El cual, por supuesto, mostramos a continuación:

1
Son las mencionadas en el documento de indicaciones de esta tarea.

8
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;
use IEEE.std_logic_unsigned.all;
entity jk is
port (
clear: in bit;
set: in bit;
J: in bit;
K: in bit;
CLK: in bit;
Q: out bit;
Q_negado: out bit );
end jk;
architecture arch_1 of jk is
signal estado: bit;
begin
process (CLK,clear,set)
begin
if (set='0' and clear='1') then estado <='0';
elsif (set='1' and clear='0') then estado <='1';
elsif CLK='1' then
if (J='0' and K='1') then estado <='0';
elsif (J='1' and K='0') then estado <='1';
elsif (J='1' and K='1') then estado <= not estado;
end if;
end if;
end process;
Q <= estado;
Q_negado <= not estado;
end arch_1;

Hecho esto, simulamos el macro utilizando este código para observar el funcionamiento.
Este FF es uno de los más usados en los circuitos digitales, y de hecho es parte
fundamental de muchos circuitos avanzados como contadores y registros de corrimiento,
que ya vienen integrados en un chip. Este FF cuenta con dos entradas de datos J y K, su
función es en principio la misma que el Registro básico NAND o NOR, pero con la
diferencia que la condición en las entradas J = 1, K = 1, a diferencia del Registro NAND, que
generaría una salida errónea o no deseada, en un FF J-K, obliga a las salidas a conmutar su
estado al opuesto (Toggle) a cada pulso del reloj. Esto lo convierte en un tipo de FF muy
versátil.

9
Hecho eso, mostramos la correcta conexión del circuito en TINA:

Anteriormente se mencionó el funcionamiento una breve aplicación de este flip flop, por
lo que ahora mostramos los resultados que se obtienen.

10
Estos resultados, son los esperados.

11
Flip-flop RS con entradas adicionales SET y RESET.

Tomando en consideración las tablas respectivas a este flip flop:, que mostramos a
continuación:

FLIP - FLOP "SR"

Tabla de
Tabla de excitación entrada
CLK S R Q* Q Q* S R
0 X X Q 0 0 0 X
1 0 0 Q 0 1 1 0
1 0 1 0 1 0 0 1
1 1 0 1 1 1 X 0
1 1 1 No vale

Una breve descripción del flip flop y lo que se espera en la simulación:

El flip-flop SR con clock se compone de una base ni flip-flop y dos puertas. Las salidas de
las dos puertas AND se mantienen a 0 mientras el pulso de reloj (o PC) es 0,
independientemente de la S y los valores de entrada R. Cuando el pulso de reloj pasa a 1,
la información de las entradas S y R pasa a través del flip-flop básico. Con tanto S = 1 y R =
1, la ocurrencia de un pulso de reloj hace que las dos salidas para ir momentáneamente a
0. Cuando se retira el pulso, el estado del flip-flop es indeterminada, es decir., Puede dar
como resultado cualquiera de los estados, dependiendo en si el conjunto o la entrada del
flip-flop restablecer sigue siendo un 1 más larga que la transición a 0 en el final del pulso.
Por consiguiente, basándonos en lo anterior, construimos nuestro código en VHDL.

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;
use IEEE.std_logic_unsigned.all;
entity sr is
PORT (
clear: in bit;
set: in bit;
S: in bit;
R: in bit;
CLK: in bit;
Q: out bit;
Q_negado: out bit );--esto es Q negado

12
end sr;

architecture arch_1 of sr is
signal estado: bit;
BEGIN
process (CLK,clear,set)
begin
if (set='0' and clear='1') then estado <='0';
elsif (set='1' and clear='0') then estado <='1';
elsif CLK='1' then
if (S='0' and R='1') then estado <='0';
elsif (S='1' and R='0') then estado <='1';
elsif (S='1' and R='1') then estado <= not estado;
end if;
end if;
end process;
Q <= estado;
Q_negado <= not estado;
end arch_1;

Es de notar que las condiciones if-else facilitan la programación, puesto que solo se le ha
dicho al dispositivo que reaccione cuando las condiciones de las sentencias mismas se
cumplan, de lo contrario el no reaccionara, esto es muy indispensable ya que no es
necesario programar todas las combinaciones posibles y determinar cuál de ellas es la que
necesitamos. Rápidamente, creamos nuestro nuevo Macro Wizard en TINA, y mostramos
la forma correcta de conexión:

Paso siguiente, iniciamos la simulación de nuestro dispositivo y estos son los resultados
que obtuvimos:

13
14
15
Es un poco difícil mostrar el cambio en solo tres imágenes, para dar solución a esto;
mostramos a continuación los gráficos de pulso de este dispositivo; que nos dará una
mejor visión de lo que está sucediendo:

Flip-flop D con entradas SET y RESET

De nuevo, recurrimos a las tablas de excitación y de entrada para encontrar la lógica en

nuestra programación:
FLIP - FLOP "D"
Tabla de
Tabla de excitación entrada
CLK D Q* Q Q* D
0 X Q 0 0 0
1 0 0 0 1 1
1 1 1 1 0 0
  1 1 1

Usando lo anterior, procedemos a crear nuestro código en VHDL, usando las librerías
aprendidas en la guía de información proporcionada para la realización de esta tarea:

16
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;
use IEEE.std_logic_unsigned.all;
entity d is
port (
clear: in bit;
set: in bit;
D: in bit;
CLK: in bit;
Q: out bit;
Q_negado: out bit );
end d;
architecture arch_1 of d is
signal estado: bit;
begin
process (CLK,clear,set)
begin
if (set='0' and clear='1') then estado <='0';
elsif (set='1' and clear='0') then estado <='1';
elsif CLK='1' then
Q <= D;
end if;
end process;
Q <= estado;
Q_negado <= not estado;
end arch_1;

Una breve descripción del comportamiento de este flip flop

El flip-flop D es una modificación de la velocidad de reloj flip-flop SR. La entrada D va

directamente a la entrada S y el complemento de la entrada D va a la entrada R. La
entrada D se muestrea durante la ocurrencia de un pulso de reloj. Si es 1, el flip-flop se
cambia al estado de ajuste (a menos que ya se ha establecido). Si es 0, el flip-flop pasa al
estado claro. Sabiendo esto, procedemos a crear nuestro macro en TINA. A continuación
mostramos su correcta conexión para que su comportamiento sea como debe ser:

17
Es bueno señalar una pequeño detalle, si ponemos atención a la conexión; las entradas
clear, set y d, varían muy diferente en el tiempo; si estas tres entradas tienen la misma
frecuencia, no se lograra apreciar su comportamiento mientras esté conectado; por lo que
sus frecuencias fueron establecidas de esa forma. Sin más que agregar, mostramos los
resultados de nuestra simulación:

18
Nuevamente, es demasiado difícil mostrar el comportamiento ya que va variando en el
tiempo, por lo que resulta mas fácil mostrarlo en una grafico de onda cuadrada: que
presentamos a continuación:

19
Contador síncrono UP/DOWN MOD 10

Hasta el momento, hemos nada más simulado lo que son los flip flops en si, pero ahora
mostramos una aplicación de los mismos, que son los contadores. Estos dispositivos, valga
la redundancia, cuentan en diferentes secuencias que el diseñador establezca para su
beneficio. En este caso específico, un contador UP and DOWN MOD 10, nos indica lo
siguiente:

 Hará en total 10 conteos, del 0 al 9.

 Si se le da la orden de que cuenta en forma UP, lo hará de la siguiente forma:
0,1,2,3,4,5,8,6,8,9,0... Cabe señalar que al llegar al digito 9, este regresara de
nuevo al principio y así sucesivamente.
 Si se le da la orden de que cuente de forma DOWN, lo hará en “cuenta regresiva”,
ósea 9,8,7,6,5,4,3,2,1,0,9…
Teniendo estos tres detalles claros, procedemos a crear el código respectivo para dar
solución a este problema:

20
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
entity mod10 is port(
clr, clk, ctrl: in std_logic;
QD, QC, QB, QA: out std_logic);
end mod10;
architecture arch_1 of mod10 is
signal pre_q: unsigned(3 downto 0);
begin
process (clk, clr)
begin
if ctrl = '0' then
if clr = '1' then pre_q <= "0000";
elsif clk = '1' then
if (pre_q = "1001") then
pre_q <= "0000";
else pre_q <= pre_q + 1;
end if;
end if;
else
if clr = '1' then pre_q <= "1001";
elsif clk = '1' then
if (pre_q = "0000") then
pre_q <= "1001";
else pre_q <= pre_q - 1;
end if;
end if;
end if;
end process;
QA <= pre_q(0);
QB <= pre_q(1);
QC <= pre_q(2);
QD <= pre_q(3);
end arch_1;

21
Creamos nuestro elemento en TINA usando el código anterior y a continuación mostramos
su correcta conexión:

Cabe mencionar, que hicimos uso de un elemento en TINA, que es un display de 7

segmentos, con finalidad estética para el trabajo. Se podría utilizar los LEDs para observar
los conteos pero sería poco impráctico realizar. Antes de simular, describimos el
comportamiento de la variable de control “ctrl”, si se le activa un “0” el contador trabajara
UP y si es “1” contara DOWN.

22
23
Flip-flop T con entradas SET y RESET

No hay otra forma de realizar nuestro código para simular el funcionamiento de este flip
flop, que el uso de las tablas de excitación y de entrada para comprender y analizarlo de
manera eficiente para poder programarlo virtualmente, nos basamos en esto y las
mostramos a continuación:
FLIP - FLOP "T"
Tabla de
Tabla de excitación entrada
CLK T Q* Q Q* T
0 X Q 0 0 0
1 0 Q 0 1 1
1 1  Q́ 1 0 1
1 1 0

Como una breve descripción de este flip flop:

“El flip-flop T es una única versión de entrada del flip-flop JK. Como se muestra en la Figura
7, el flip-flop T se obtiene a partir del tipo JK si ambas entradas están unidas entre sí. La
salida del flip-flop T "cambia" con cada pulso de reloj.”
Lo anterior es lo que buscamos, poder simular las características esenciales de este flip
flop. Lo cual logrado, retomamos de nuevo el código VHDL para lograr nuestro acometido,
el mismo los mostramos a continuación:
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;
use IEEE.std_logic_unsigned.all;
entity t is
port (
clear: in bit;
set: in bit;
T: in bit;
CLK: in bit;
Q: out bit;
Q_negado: out bit );
end t;
architecture arch_1 OF t is
signal estado: bit;

24
 begin
process (CLK,clear,set)
begin
if (set='0' and clear='1') then estado <='0';
elsif (set='1' and clear='0') then estado <='1';
elsif CLK='1' then
if (CLK='1' and T='1') then estado <= not estado;
end if;
end if;
end process;
Q <= estado;
Q_negado <= not estado;
end arch_1;

Luego de esto, de nuevo simulamos nuestro circuito utilizando los micros de TINA. Hecho
eso, mostramos la forma correcta de conectarlo:

Cabe mencionar lo siguiente, las entradas clear set y T, poseen una frecuencia de pulso
diferentes, con el propósito de apreciar el comportamiento correcto de este flip flop. Es
muy importante este paso ya que si no se hace y se deja constante la frecuencia en ambos
casos, no se verá ningún de los funcionamientos que dicta las tablas de excitación y
entrada y el trabajo será de por gusto. Insistimos en realizar ese pequeño paso para poder
dar conclusiones verdades y argumentadas.
Por lo tanto, hecho todo lo anterior y asegurarnos de que nuestro código este correcto y
la conexión bien realizada, mostramos a continuación los resultados del comportamiento
del FLIP FLOP T:

25
26
Reloj Digital

El siguiente circuito, se nos solicitar programar y simular un reloj de 24 horas, que muestre
también los minutos, segundos; utilizando los flip flops descritos en este reporte. Para
poder empezar, es necesario tener cuenta que ocuparemos y como lo haremos; los pasos
básicos se muestran a continuación.

 Es necesario la creación de un contador MOD10, para que lleve control de los

segundos.
 Creación de un contador MOD 6 para los minutos.
 Crear un contador MOD 3 para las decenas de las horas en formato de 24 horas.
 Sera un circuito asíncrono, ya que el cambio en minutos depende de los segundos
y las horas del cambio que sufrirán los minutos y así sucesivamente. El pulso
principal ira al contador de los segundos, donde ahí se derivaran el
comportamiento del resto de los circuitos.
 Es necesario un decodificador. Los resultados serán pulsos por lo que es necesario
la conversión de estos a un display de 7 segmentos para lograr observar los
resultados que se esperan.
Teniendo claro lo anterior, y aplicando la guía proporcionada para la realización de esta
tarea, procedemos entonces a crear los diferentes circuitos para dar solución a nuestro
problema. Empezamos con los contadores.
CONTADOR MOD 10 (SEGUNDOS)
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;

ENTITY segundos IS
PORT( clear, click :IN std_logic;
QA, QB, QC, QD :OUT std_logic);

END segundos;

ARCHITECTURE arch_1 OF segundos IS

SIGNAL QN : UNSIGNED(3 DOWNTO 0 );
BEGIN
PROCESS(click,clear)
BEGIN
IF clear='1' THEN
QN <= "0000";
ELSIF(click = '0' AND click'event)THEN

27
 QN <= QN + 1;
END IF;

IF(QN = "1010")THEN
QN <= "0000";
END IF;
END PROCESS;
QA <= QN(3);
QB <= QN(2);
QC <= QN(1);
QD <= QN(0);
END arch_1;

CONTADOR MOD 6 (MINUTOS)

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
ENTITY minutos IS
PORT( clear, click :IN std_logic;
QA, QB, QC, QD :OUT std_logic);
END contador6;

ARCHITECTURE arch_1 OF minutos IS

SIGNAL QN : UNSIGNED(3 DOWNTO 0 );
BEGIN
PROCESS(click,clear)
BEGIN
IF clear='1' THEN
QN <= "0000";
ELSIF(click = '0' AND click'event)THEN
QN <= QN + 1 ;
END IF;
IF(QN = "0110")THEN
QN <= "0000";
END IF;
END PROCESS;
QA <= QN(3);
QB <= QN(2);
QC <= QN(1);
QD <= QN(0);
END arch_1;

28
 CONTADOR MOD 3 (CONTADOR DECENAS PARA 24 HORAS)

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;

ENTITY horas IS
PORT( clear, click :IN std_logic;
QA, QB, QC, QD :OUT std_logic);
END horas;
ARCHITECTURE arch_1 OF horas IS
SIGNAL QN : UNSIGNED(3 DOWNTO 0 );
BEGIN
PROCESS(click,clear)
BEGIN
IF clear='1' THEN
QN <= "0000";
ELSIF(click = '0' AND click'event)THEN
QN <= QN + 1 ;
END IF;
IF(QN = "0011")THEN
QN <= "0000";
END IF;
END PROCESS;
QA <= QN(3);
QB <= QN(2);
QC <= QN(1);
QD <= QN(0);
END arch_1;

Para lograr cambiar y establecer la hora y los minutos, es necesario tener interruptores
High and Low. El proceso para esto es ir accionando repetidas veces los mismos hasta
llegar a la hora deseada. Esto se aplica tanto para los minutos y segundos. Las conexiones
correctas se muestran a continuación. La argumentación del porque ese uso de
compuertas básicas es la guía suministrada para el desarrollo de este reporte. Se utilizaron
en función de lo que queremos obtener.

29
30
Investigación

¿Qué es un duty cicle?

Ciclo de trabajo (o factor de trabajo) es una medida de la fracción del tiempo que un radar
esté transmitiendo. Es importante porque se refiere a pico y potencia media en la
determinación de la producción total de energía. Esto, a su vez, en última instancia, afecta
a la fuerza de la señal reflejada, así como la capacidad de la fuente de alimentación
requerida y los requisitos de refrigeración del transmisor.
Aunque hay excepciones, la mayoría de las mediciones de frecuencia de radio (RF) son de
onda continua (CW) o pulsado
De RF. CW RF es de RF ininterrumpida como por ejemplo de un oscilador. Con modulación
de amplitud (AM), frecuencia modulada (FM), y modulada en fase (PM) RF se consideran
CW desde la RF está continuamente presente. La potencia puede variar con el tiempo
debido a la modulación, pero RF está siempre presente. RF pulsada, por otro lado, es
ráfagas (pulsos) de RF con ninguna de RF entre presente explosiones. El caso más general
de RF pulsada consiste en pulsos de un ancho de pulso fijo (PW), que vienen en un
momento fijo intervalo o período (T). Para mayor claridad y facilidad de esta discusión, se

31
asume que todos los pulsos de RF en un tren de pulsos tienen la misma amplitud. Los
pulsos en un intervalo fijo de tiempo llegan a un ritmo o frecuencia referida como la
frecuencia de repetición de impulsos (PRF) de tantos impulsos por segundo. Intervalo de
repetición de impulsos (PRI) y PRF son recíprocos entre sí.
El valor promedio se define como ese nivel en el que el área de pulso por encima de la
media es igual a la zona de debajo de la media entre los pulsos. Si los impulsos son
igualados en una manera tal como para rellenar el área entre pulsos, el nivel obtenido es
el valor medio, donde se utiliza el área sombreada del pulso para llenar en la zona entre
los pulsos. El área del pulso es el ancho de pulso multiplicado por la potencia de cresta del
impulso. La zona media es igual al valor promedio de potencia multiplicado por el período
de pulso.

32
Investigue las librerías de ALTERA, que permiten usar flip-flop ya diseñados,
escriba el código necesario para usar estos componentes.

lpm_ff Megafunction.

Parameterized megafunction flipflop. La función lpm_ff contiene características que no

están disponibles en el DFF, DFFE, DFFEA, DFFEAS, TFF, y las primitivas TFFE, tal como se
establece sincrónica o asincrónica, claro, y las entradas de carga. El megafunction lpm_ff
está disponible para todos los dispositivos de Altera.Altera recomienda crear instancias de
esta función con el MegaWizard Plug-In Manager.

Nota: Puede utilizar el editor de misiones para añadir, cambiar o eliminar las asignaciones
y los valores de asignación de megafunctions.

El prototipo de la siguiente función AHDL se encuentra en el Archivo de AHDL Include (.

Inc) lpm_ff.inc en la instalación <Quartus II directorio de \ bibliotecas \ megafunctions
directorio.

FUNCTION lpm_ff (data[LPM_WIDTH-1..0], clock, enable,sclr, sset, sload,aclr, aset, aload)

WITH (LPM_WIDTH, LPM_AVALUE, LPM_SVALUE, LPM_FFTYPE)
RETURNS(q[LPM_WIDTH-1..0]);
La siguiente declaración VHDL componente se encuentra en el archivo de diseño VHDL (.
Vhd) LPM_PACK.vhd en la instalación <Quartus II directorio de \ bibliotecas \ VHDL \ lpm
directorio.

component LPM_FF
generic (LPM_WIDTH : natural; -- MUST be greater than 0
LPM_AVALUE : string := "UNUSED";
LPM_SVALUE : string := "UNUSED";
LPM_PVALUE : string := "UNUSED";
LPM_FFTYPE: string := "DFF";
LPM_TYPE: string := L_FF;
LPM_HINT : string := "UNUSED");
port (DATA : in std_logic_vector(LPM_WIDTH-1 downto 0);
CLOCK : in std_logic;
ENABLE : in std_logic := '1';
SLOAD : in std_logic := '0';
SCLR : in std_logic := '0';
SSET : in std_logic := '0';
ALOAD : in std_logic := '0';
ACLR : in std_logic := '0';
ASET : in std_logic := '0';
Q : out std_logic_vector(LPM_WIDTH-1 downto 0));

33
end component;
El VHDL BIBLIOTECA DE USO declaración no es necesaria si se utiliza la Declaración de
componentes VHDL.

LIBRARY altera_mf;
USE lpm.lpm_components.all;

Investigue algunas formas de crear un tren de pulsos.

Un tren de pulsos podemos decir que es una señal de reloj con cada uno de sus pulsos
retrasados entre si por una unidad de tiempo. VHDL permite especificar un retardo de
tiempo utilizando la palabra clave after en cualquier instrucción de asignación de señal.

Z<=’1’ after 4 ns when X=’1’ and Y=’0’ else ‘0’ after 3 ns;

--EJEMPLO 1 GENERACIÓN DE SEÑAL DE RELOJ

--Si no hay una lista de sensibilidades ni sentencias wait
--El proceso siempre está activo y permanece en bucle infinito

process
begin
if clk=´1´then clk<=´0´after 10 ns;
else clk<=´1´ after 15 ns;
end if;
end process;

--EJEMPLO 2 IDEM CON LISTA DE SENSIBILIDADES

--El proceso se suspende al ejecutar la última instrucción
--Se reactiva cuando hay un evento en la señal CLK y
--comienza la ejecución a partir de la primera sentencia

process (clk)
begin
if clk=´1´then clk<=´0´after 10 ns;
else clk<=´1´ after 15 ns;
end if;
end process;

34
--EJEMPLO3 IDEM UTLIZANDO WAIT
--El proceso se suspende al llegar al WAIT
--Se reactiva cuando hay un evento en la señal CLK y
--comienza la ejecución a partir de la primera sentencia

process
begin
if clk=´1´then clk<=´0´after 10 ns;
else clk<=´1´ after 15 ns;
end if;
wait on clk;
end process;

¿Es posible generar con un 555 un tren de pulsos con Duty-Cicle de 50%?

El multivibrador astables: relojes. Un multivibrador es un circuito generador de pulsos que

produce una salida de onda rectangular. Se clasifican en biestables o monoestables El
multivibrador astable genera un flujo continuo de pulsos. El temporizador CI 555 puede
utilizarse para implementar multivibradores astables, biestables o monoestables.

35
Conclusiones

Podemos identificar dos tipos de lógicas, la lógica secuencial y la lógica combinatoria; se

puede distinguir que los componentes MSI no toman en cuenta si el conteo es UP o si es
DOWN, pues están fijos en el valor de entrada respectivo siendo por esta característica
muy utilizados en las telecomunicaciones. Los dispositivos de lógica secuencial las salidas
dependen del estado presente y del estado siguiente de las respectivas variables de
entrada, por esta característica son muy utilizados en las aplicaciones de control de flujo
de información como los buses de datos de comunicación de las computadoras llamadas
unidades lógicas entre otras.
Anteriormente el conteo era por mecanismos de engranaje, siendo el más notorio y aun
existente el reloj de engranajes, con el avance de la tecnología y el uso de contadores
mediante los Flip Flop se pasó del reloj de engranajes a los relojes digitales. Pero no solo
se utilizó este avance en los relojes digitales sino que también en diferentes contadores
secuenciales e incluso en dispositivos que generen datos cuantitativos de determinadas
acciones. Podemos verlos en los display de pantallas de equipos de audio y video en los
cuales se lleva un conteo del progreso de una pista, duración del tiempo etc. En
conclusión podemos afirmar que en día es necesario poder llevar un conteo de lo que
realizamos. Es por eso que es necesario crear dispositivos que satisfagan esta necesidad.

36
Bibliografía

 http://es.wikipedia.org/wiki/Sistema_secuencial
 http://es.wikipedia.org/wiki/Biestable
 http://www.forosdeelectronica.com/tutoriales/flip-flops.htm
 http://www.tscm.com/dutycy.pdf
 http://en.wikipedia.org/wiki/Duty_cycle

37