introduccion al lenguaje vhdl
DESCRIPTION
Introduccion y desarrollo de aplicaciones usando el lenguaje VHDL.TRANSCRIPT
UNIVERSIDAD DE EL SALVADOR | FACULTAD DE INGENIERIA Y ARQUITECTURA
INTRODUCCIÓN AL LENGUAJE VHDL
Sistemas Digitales I
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: Martes 25 de marzo de 2014
Tabla de Contenido Introducción ........................................................................................................................................ 2
Objetivos ............................................................................................................................................. 3
Instalación del programa en Microsoft Windows ............................................................................... 4
Marco Teórico ................................................................................................................................... 10
Realizar el código VHDL para las compuertas: AND, NAND, OR, NOR, EXOR y NOT, simular en TINA
y VHDL ............................................................................................................................................... 12
Compuerta AND ............................................................................................................................ 12
Compuerta NAND .......................................................................................................................... 13
Compuerta OR ............................................................................................................................... 13
Compuerta NOR ............................................................................................................................ 14
Compuerta EXOR ........................................................................................................................... 15
Compuerta NOT ............................................................................................................................ 15
Ejercicio 1 : Realizar el código VHDL para el ejemplo 2.35 del libro. ................................................ 17
Ejercicio 2: Realizar el código VHDL para el problema 2.35 del final del capítulo. ........................... 18
Ejercicio 3: Circuito 3: “Un automóvil a prueba de choques” ........................................................... 19
Respuestas a las preguntas de investigación .................................................................................... 22
Uso y sintaxis de las instrucciones IF… THEN. ............................................................................... 22
Uso y sintaxis de la instrucciones CASE… WHEN........................................................................... 22
Uso de las instrucciones anteriores para implementar el código VHDL directamente desde las
tablas de verdad. ........................................................................................................................... 24
Ejercicio 1 .................................................................................................................................. 24
Ejercicio 2 .................................................................................................................................. 24
Tipos de datos de entrada y salida que soporta VHDL. ................................................................ 25
Cómo se crean arreglos en VHDL? ................................................................................................ 27
Cómo declarar un componente en VHDL? .................................................................................... 27
¿Cuáles son los operadores en VHDL? .......................................................................................... 28
Conclusiones ..................................................................................................................................... 30
Bibliografía ........................................................................................................................................ 31
2
Introducción
Con el paso de los años el ser humano ha adquirido y desarrollado conocimientos que le han llevado a posicionarse en la era digital, pues podemos ver que muchos objetos que antes utilizaban mucho espacio debido a sus componentes electrónicos hoy en día se han convertido en objetos de menor tamaño, pero ¿A qué se debe esto? La respuesta está a la palma de la mano como también en la palma de la mano podemos tener unos circuitos digitales que han venido a sustituir grandes circuitos, contribuyendo así a poder estar más digitalizados, pero ¿Cómo se realizan estos circuitos?, hay diferentes lenguajes de programación que son utilizados para desarrollar códigos para simular circuitos usados en estos nuevos artefactos, como ejemplo tendremos el lenguaje VHDL que utilizaremos para la implementación de códigos que simulen las compuertas lógicas y así poder implementarlas a un circuito que lo podemos usar en un juguete, los códigos de programación y los diferentes lenguajes nos ayudan a poder corregir errores antes de la implementación de los circuitos encargados muchas veces de procesos que son muy precisos. En este reporte se usan las compuertas lógicas más conocidas pues en base a ellas del cual surgen los demás circuitos e incluso la unión de estas para formar circuitos más complejos.
3
Objetivos
Usar de manera eficiente la sintaxis básicas de VHDL en Maxi Plus.
Resolver ejercicios propuestos usando la misma sintaxis.
Dar conclusiones de las posibles aplicaciones de los ejercicios propuestos en la vida
cotidiana.
Reconocer la importancia e influencia que ha tenido este lenguaje de programación en la
actualidad.
Enseñar al lector la instalación de una manera rápida del programa a utilizar en este
trabajo.
4
Instalación del programa en Microsoft Windows 1. Vamos al siguiente link: https://www.altera.com/download/legacy/maxplus2/dnl-
student.jsp?swcode=WWW-SWD-MP2-SE102-PC y nos aparecerá lo siguiente. Damos click
a la descarga. La página pedirá un registro de usuario, proceder con eso y seguir con la
descarga.
2. Esperar a que se descargue y abrir el instalador:
5
3. Damos a Next: a todo lo que aparezca después d esta primer ventana:
4. Aquí ponemos cualquier cosa
6
5. Elegimos todo los componentes y damos siguiente:
6. Esperamos a que se instale. CUANDO ESTA VENTANA CIERRE EL PROGRAMA SE HABRA
INSTALADO CORRECTAMENTE. IMPORTANTE, DESPUES DE ESTO “NO” ABRIR POR QUE SE
TIENE QUE INSTALAR LA LICENCIA
7
7. Para poder obtener la licencia de uso completo del programa, vamos al siguiente link:
http://www.altera.com/support/licensing/lic-university.html
8. Damos a continue y aparecerá lo siguiente, donde se nos pedirá el serial de nuestro disco
duro.
8
9. Por lo cual hacemos lo siguiente, ejecutamos el cmd o símbolo de sistema en Windows
como administrador.
10. Digitamos lo siguiente “dir/p” sin comillas y aparecerá la siguiente ventana: Copiar ese
código a mano, aquí se presenta el número de serie de esta forma XXXX-XXXX, quitar el
guion a la hora de ingresarlo en la página de altera.
9
11. Después de ingresar los datos, nos pedirá llenar el formulario, escribir cualquier cosa en
los espacios, menos en la casilla del correo que tendrá que ser uno nuestro porque ahí se
llegara nuestra licencia,
12. Ya recibida la licencia, el archivo que nos mandan lo pegamos en la carpeta de instalación
del Max Plus. Luego abrimos de nuevo el programa y vamos a Options---License Setup,
damos a Browse y buscamos el archivo que nos mandaron a nuestro correo. Listo el
programa está instalado correctamente.
10
Marco Teórico
Los lenguajes de descripción hardware (HDLs, Hardware Description Languages) vienen
utilizándose desde los años 70 en los ciclos de diseño de sistemas digitales asistidos por
herramientas de CAD electrónico. Al principio surgieron una serie de lenguajes que no
llegaron a alcanzar un éxito que permitiera su consolidación en el campo industrial o
académico. En los años 80 aparecen los lenguajes Verilog y VHDL que, aprovechando la
disponibilidad de herramientas hardware y software cada vez más potentes y asequibles y
los adelantos en las tecnologías de fabricación de circuitos integrados, logran imponerse
como herramientas imprescindibles en el desarrollo de nuevos sistemas. En la actualidad
ambos lenguajes están normalizados y comparten una posición hegemónica que está
arrinconando –y terminará, probablemente, en poco tiempo eliminando del mercado– al
resto de lenguajes que de un modo u
otro todavía son soportados por algunas herramientas de CAD.
Estos lenguajes son sintácticamente similares a los de programación de alto nivel –Verilog
tiene una sintaxis similar al C y VHDL a ADA– y se diferencian de éstos en que su semántica
está orientada al modelado del hardware. Su capacidad para permitir distintos enfoques
en el modelado de los circuitos y su independencia de la tecnología y metodología de
diseño permiten extender su uso a los distintos ciclos de diseño que puedan utilizarse. Por
ello, para los profesionales relacionados de alguna manera con el diseño o mantenimiento
de sistemas digitales resulta hoy en día imprescindible su conocimiento.
Los estudios para la creación del lenguaje VHDL (VHSIC HDL) comenzaron en el año 1981,
bajo la cobertura de un programa para el desarrollo de Circuitos Integrados de Muy Alta
Velocidad (VHSIC), del Departamento de Defensa de los Estados Unidos. En 1983 las
compañías Intermetrics, IBM y Texas Instruments obtuvieron la concesión de un proyecto
para la realización del lenguaje y de un conjunto de herramientas auxiliares para su
aplicación.
Finalmente, en el año 1987, el lenguaje VHDL se convierte en la norma IEEE-1076 –como
todas las normas IEEE, se somete a revisión periódica, por lo que en 1993 sufrió algunas
leves modificaciones–.
11
El lenguaje VHDL fue creado con el propósito de especificar y documentar circuitos y
sistemas digitales utilizando un lenguaje formal. En la práctica se ha convertido, en un
gran número de entornos de CAD, en el HDL de referencia para realizar modelos
sintetizables automáticamente. Las principales características del lenguaje VHDL se
explican en los siguientes puntos:
Descripción textual normalizada: El lenguaje VHDL es un lenguaje de descripción que
especifica los circuitos electrónicos en un formato adecuado para ser interpretado tanto
por máquinas como por personas. Se trata además de un lenguaje formal, es decir, no
resulta ambiguo a la hora de expresar el comportamiento o representar la estructura de
un circuito. Está, como ya se ha dicho, normalizado, o sea, existe un único modelo para el
lenguaje, cuya utilización está abierta a cualquier grupo que quiera desarrollar
herramientas basadas en dicho modelo, garantizando su compatibilidad con cualquier
otra herramienta que respete las indicaciones especificadas en la norma oficial. Es, por
último, un lenguaje ejecutable, lo que permite que la descripción textual del hardware se
materialice en una representación del mismo utilizable por herramientas auxiliares tales
como simuladores y sintetizadores lógicos, compiladores de silicio, simuladores de
tiempo, de cobertura de fallos, herramientas de diseño físico, etc.
Amplio rango de capacidad descriptiva: El lenguaje VHDL posibilita la descripción del
hardware con distintos niveles de abstracción, pudiendo adaptarse a distintos propósitos
y utilizarse en las sucesivas fases que se dan en el desarrollo de los diseños. Además es un
lenguaje adaptable a distintas metodologías de diseño y es independiente de la
tecnología, lo que permite, en el primer caso, cubrir el tipo de necesidades de los distintos
géneros de instituciones, compañías y organizaciones relacionadas con el mundo de la
electrónica digital; y, en el segundo, facilita la actualización y adaptación de los diseños a
los avances de la tecnología en cada momento.
Otras ventajas: Además de las ventajas ya reseñadas también es destacable la capacidad
del lenguaje para el manejo de proyectos de grandes dimensiones, las garantías que
comporta su uso cuando, durante el ciclo de mantenimiento del proyecto, hay que
sustituir componentes o realizar modificaciones en los circuitos, y el hecho de que, para
muchas organizaciones contratantes, sea parte indispensable de la documentación de los
sistemas.
12
Realizar el código VHDL para las compuertas: AND, NAND, OR, NOR, EXOR y
NOT, simular en TINA y VHDL
Compuerta AND ENTITY com_and IS PORT( a,b :IN BIT; x :OUT BIT); END com_and; ARCHITECTURE arch_and OF com_and IS BEGIN x<= a AND b; END arch_and;
13
Compuerta NAND ENTITY comp_nand IS PORT( a,b :IN BIT; x :OUT BIT); END comp_nand; ARCHITECTURE arch_nand OF comp_nand IS BEGIN x<= a NAND b; END arch_nand;
Compuerta OR ENTITY comp_or IS PORT( a,b :IN BIT; x :OUT BIT); END comp_or; ARCHITECTURE arch_or OF comp_or IS BEGIN x<= a OR b; END arch_or;
14
Compuerta NOR ENTITY comp_nor IS PORT( a,b :IN BIT; x :OUT BIT); END comp_nor; ARCHITECTURE arch_nor OF comp_nor IS BEGIN x<= a NOR b; END arch_nor;
15
Compuerta EXOR ENTITY comp_xor IS PORT( a,b :IN BIT; x :OUT BIT); END comp_xor; ARCHITECTURE arch_xor OF comp_xor IS BEGIN x<= a XOR b; END arch_xor;
Compuerta NOT ENTITY comp_not IS PORT( a :IN BIT; x :OUT BIT); END comp_not; ARCHITECTURE arch_not OF comp_not IS BEGIN x<= NOT(a); END arch_not;
16
17
Ejercicio 1 : Realizar el código VHDL para el ejemplo 2.35 del libro.
Tabla de Verdad
A B C X
0 0 0 0
0 0 1 1
0 1 0 1
0 1 1 0
1 0 0 0
1 0 1 0
1 1 0 1
1 1 1 1
ENTITY circuito_1 IS PORT( a,b,c :IN BIT; y,z :OUT BIT); END circuito_1; ARCHITECTURE arch_1 OF circuito_1 IS BEGIN y <= ((NOT a) AND (NOT b) AND c) OR (b AND (NOT c)) OR (a AND b) ; z <= ((NOT a) AND c) OR ((NOT a) AND b AND c) OR (a AND b AND (NOT c)) ; END arch_1;
18
Ejercicio 2: Realizar el código VHDL para el problema 2.35 del final del capítulo.
Entity prob_235 IS PORT( a,b,c,d :IN BIT; x :OUT BIT); END prob_235; ARCHITECTURE arch_235 OF prob_235 IS BEGIN x <= ((NOT a) AND (NOT b) AND (NOT c) AND d) OR ((NOT a) AND (NOT b) AND c AND (NOT d)) OR ((NOT a) AND b AND (NOT c ) AND (NOT d)) OR ((NOT a) AND b AND c AND d) OR (a AND (NOT b) AND (NOT c ) AND (NOT d)) OR ( a AND (NOT b) AND c AND d) OR (a AND b AND(NOT c ) AND d ) OR ( a AND b AND c AND (NOT d)); END arch_235;
19
Ejercicio 3: Circuito 3: “Un automóvil a prueba de choques” Descripción: se trata de un automóvil con tres sensores, uno al frente y dos a los costados, al
arrancar se dirige hacia adelante, al encontrar un obstáculo gira, a uno de los costados esquivando
el obstáculo. La posición de los sensores se muestra en la siguiente figura.
Para girar a los lados, hace que las llantas giren en distintas direcciones, como por ejemplo para
girar a la izquierda, las llantas “X” rotan hacia atrás mientras que las llantas “Y” hacia adelante,
para hacer que el par de llantas “X” giren hacia adelante se debe poner en una variable de control
llamada “X” bit 0, para que giren hacia atrás X=1, igual para el par de llantas “Y”, con su respectiva
variable de control “Y”, la lógica de control de las llantas es la siguiente.
20
X Y Descripción
0 0 Hacia Adelante
0 1 Hacia la derecha
1 0 Hacia la izquierdo
1 1 Hacia Atrás.
Si los tres sensores A, B, C están en “1” es decir, detecta obstáculo en las tres direcciones,
empezara a retroceder, de lo contrario girara en la en la dirección que esté libre de obstáculo, si
existe la posibilidad de girar hacia la derecha o hacia la izquierda se girara a la derecha.
TABLA DE VERDAD
A B C Y Z
0 0 0 0 0 0 0 1 1 0 0 1 0 0 1 0 1 1 1 0 1 0 0 0 1 1 0 1 0 0 1 1 0 0 1 1 1 1 1 1
ENTITY circuito_3 IS PORT( a,b,c :IN BIT; x,y :OUT BIT); END circuito_3; ARCHITECTURE arch_3 OF circuito_3 IS BEGIN x <= ((NOT a) AND c) OR (b AND c) ; y <= (a AND (NOT c)) OR ((NOT a) AND b AND (NOT c)) OR (a AND b AND c) ; END arch_3;
21
22
Respuestas a las preguntas de investigación
Uso y sintaxis de las instrucciones IF… THEN. La construcción if-then-else es usada para seleccionar un conjunto de sentencias para ser
ejecutadas según la evaluación de una condición o conjunto de condiciones, cuyo resultado debe
ser o true o false. Su estructura es la siguiente:
if (condición)
then haz una cosa;
else haz otra cosa diferente;
end if;
Si la condición entre paréntesis es verdadera, la(s) sentencia(s) secuencial(es) seguidas a la palabra
then son ejecutadas. Si la condición entre paréntesis es falsa, la(s) sentencia(s) secuencial(es)
seguidas a la palabra else son ejecutadas. La construcción debe ser cerrada con las palabras end if.
Uso y sintaxis de la instrucciones CASE… WHEN.
La sentencia case es usada para especificar una serie de acciones según el valor dado de una señal
de selección. Esta sentencia es equivalente a la sentencia with-select-when, con la salvedad que la
sentencia que nos ocupa es secuencial, no combinacional. La estructura es la siguiente:
case (señal a evaluar) is
when (valor 1) => haz una cosa;
when (valor 2) => haz otra cosa;
...
when (último valor) => haz tal cosa;
end case;
En el caso que la señal a evaluar (situada después del case) tenga el "valor 1", entonces se ejecuta
"una cosa", si tiene el "valor 2", se ejecuta "otra cosa", ... y si tiene el "último valor", se ejecuta "tal
cosa". Esta sentencia parece hecha a la medida para crear multiplexores, como se ve en el
siguiente ejemplo, del cual sólo estudiamos la parte correspondiente a la sentencia case:
entity multi is port( a, b, c :in
bit_vector(3 downto 0); enable :in bit;
23
control :in bit_vector(1 downto 0); d :out bit_vector(3 downto 0) ); end multi; architecture archmul of multi is begin process (a, b, c, control, enable) begin if enable='1' then d<="1111"; elsif enable='0' then case control is
when "00" => d <= a;
when "01" => d <= b;
when "10" => d <= c;
when "11" => d <= "1111";
end case;
end if;
end process;
end archmul;
24
Uso de las instrucciones anteriores para implementar el código VHDL directamente
desde las tablas de verdad.
A continuación mostramos los códigos modificados a fin de implementar las sentencias tanto “if”
como “case”, haciendo así que nuestro circuito sea también generado e forma de algoritmo.
Ejercicio 1
1. entity multi is port(
2. IN1,IN2,IN3,IN4,SELECT1,SELECT2:in bit;
3. Y :out bit);
4. end multi;
5. architecture archmul of multi is
6. begin
7. process (SELECT1,SELECT2)
8. begin
9. if SELECT1='1'or SELECT2='0'then Y<="1";
10. elsif SELECT1= '0' or SELECT2='0' then Y='0';
11. case control is
12. when "00" => d <= a;
13. when "01" => d <= b;
14. when "10" => d <= c;
15. when others => d <= "1111";
16. end case;
17. end if;
18. end process;
19. end archmul;
Ejercicio 2
1. entity demulti is port(
2. entra: in bit_vector(7 downto 0);
3. control: in bit_vector(1 downto 0);
4. enable: in bit;
5. a,b,c,d: out bit_vector(7 downto 0)
25
6. );
7. end demulti;
8. architecture archdemul of demulti is
9. begin
10. process (entra, control, enable)
11. begin
12. if enable='1' then a<="11111111";
13. b<="11111111";
14. c<=(others=>'1');
15. d<=(others=>'1');
16. elsif enable='0' then
17. case control is
18. when "00" => a <= entra;
19. when "01" => b <= entra;
20. when "10" => c <= entra;
21. when others => d <= entra;
22. end case;
23. end if;
24. end process;
25. end archdemul;
Tipos de datos de entrada y salida que soporta VHDL. El tipo de datos es un elemento básico en VHDL, ya que delimita que valores puede tenr un objeto
y que operaciones podemos realizar con él. Aparte de los tipos ya creados, podemos crear nuevos
tipos y subconjuntos de tipos. La declaración de un tipo de datos es la sentencia VHDL utilizada
para introducir un nuevo tipo. Esta declaración está formada por un identificador que nos
permitirá usar el nuevo tipo al llamarlo y la descripción del conjunto de valores que forman el tipo
de datos. Para ello usamos la palabra reservada type. La declaración puede tener varios formatos
como por ejemplo:
type longitud_maxima is range 2 to 50 type estados is (estado_a, estado_b, estado_c);
26
Una vez declarado el nuevo tipo podremos usarlo para declarar objetos de este tipo, como por
ejemplo:
variable est: estados; port (entrada: in estados; salida: out longitud_maxima);
Cada tipo es diferente e incompatible con los demás, aunque estén declarados de la misma forma,
por lo cual no podemos asignar a una señal de un tipo otra de otro tipo distinto, a menos que
definamos una función de transformación. Los tipos pueden ser clasificados según las
características de lo que van a determinar:
Tipos enumerados: En éste se define el conjunto de posibles valores del tipo especificado,
presentando una lista que contiene a todos los valores. El primer identificador es el
nombre del tipo y sirve para referenciarlo, y entre paréntesis y separados por comas se
adjuntan todos los valores legales del tipo. type vocales ('a', 'e', 'i', 'o', 'u'); type direcciones
is (izquierda, derecha, arriba, abajo, centro);
Si no está especificado ningún valor inicial, el objeto se inicializa con el valor más a la
izquierda de los especificados en la declaración del tipo. Es decir, un objeto del tipo
"vocales" toma el valor 'a' por defecto.
Tipos enteros / reales: Esta modalidad de tipo sirve apra definir un objeto con valores
reales y enteros. En VHDL vienen definidos el tipo integer, que puede ir desde -
2147483647 hasta 2147483647, y el tipo real, quepuede ir desde -1.0e38 hasta 1.0e38.
Para definir un tipo de esta naturaleza hay que especificar el rango de valores que puede
llegar a tener asignado un objeto, como en los ejemplos siguientes
type edad is range 0 to 150;
type dias is range 31 downto 0;
Si no está especificado ningún valor inicial, el objeto se inicializa con el valor más a la
izquierda de los especificados en la declaración del tipo. Deberemos tener cuidado si
hemos usado la palabra to o la palabra downto para definir el tipo, ya que se asignará un
valor por defecto u otro. En el ejemplo se da por defecto a un objeto del tipo "edad" el
valor 0, y a otro del tipo "dias", el valor 31.
Tipos físicos: Sirven para representar magnitudes del mundo real como el tiempo, peso,
capacidad,... por lo que llevan, aparte de un literal numérico, la magnitud física a medir.
Podemos asignar unidades auxiliares a la predefinida.
type time is range 0 to 1e20;
units fs; ps = 1000 fs;
ns = 1000 ps;
us = 1000 ns;
ms = 1000 us;
sec = 1000 ms;
min = 60 sec;
hr = 60 min;
end units;
27
Si no está especificado ningún valor inicial, el objeto se inicializa con el valor más a la
izquierda de los especificados en la declaración del tipo. Deberemos tener cuidado si
hemos usado la palabra to o la palabra downto para definir el tipo, ya que se asignará un
valor por defecto u otro. En el ejemplo se da por defecto a un objeto del tipo "edad" el
valor 0, y a otro del tipo "dias", el valor 31.
Cómo se crean arreglos en VHDL? Son tipos complejos con una estructura regular que contiene elementos del mismo tipo. El
número de elementos está especificado en el mismo rango del arreglo. El rango puede ser
ilimitado: range < > (aunque no es lo más conveniente). Hay dos arreglos pre-definidos en
VHDL :
Bit_Vector : Con elementos del tipo Bit, y
String : Con elementos de tipo carácter.
Cómo declarar un componente en VHDL? Para declarar un componente en VHDL podemos utilizar la siguiente sintaxis general:
COMPONENT nombre IS GENERIC(lista de parámetros);
PORT(lista de puertos de entrada y salida);
END COMPONENT nombre;
Si nos damos cuenta al comparar esta declaración con la de una entidad podemos denotar un gran
parecido. Ahora bien también daremos un ejemplo de un componente:
COMPONENT comp_and2
PORT(
e1,e2: IN bit; o: OUT bit);
END COMPONENT comp_2and;
28
¿Cuáles son los operadores en VHDL?
29
30
Conclusiones
Hemos podido apreciar que el uso de este programa fue nuevo para nosotros, su sintaxis parecía
ser difícil pero con la práctica todo se puede lograr. Este lenguaje de programación es muy fuerte,
el límite de este es la imaginación. Como se vio en los ejemplos anteriores la sintaxis fue muy
corta, pero capaz de resolver problemas que a simple vista suena de una manera imposible, este
no, aplicando conceptos de Algebra de Boole se pudo realizar sin mayor problema dando asi a la
solución del mismo. De igual forma los demás circuitos propuestos, se logra en si poder dar lectura
y comprensión al código base de este lenguaje de programación.
Concluimos entonces que la resolución de los problemas cotidianos se pueden resolver de muchas
maneras, hay unos de una y otros de otra; claro está que para algún circuito que habrá una puerta
con impulsos eléctricos se debe de tomar en cuenta el lenguaje tratado en este trabajo; es más
sencillo y gracias a esa algebra el problema se soluciona muy rápidamente.
Entendemos también que estos códigos pueden ser fáciles, la misma lógica de cursos pasados se
han aplicado aquí, pero algo tan sencillo como una compuerta not , el no saber sintaxis lleva al
desbordamiento de nuestro trabajo y pone en peligro el mismo, ya que si uno ya en el futuro
trabajando se topa con un problema asi y no logra solucionarlo; perderemos esa experiencia y nos
quedaremos en el vacío existencial no poder aprender algo tan sencillo como esa sintaxis, por lo
tanto este curso de Sistemas Digitales será un reto, donde aprenderemos a solucionar inquietudes
del día a día para el mejoramiento de nuestra realidad, y a corto plazo poder tener esas bases para
cursos posteriores a esta materia que se ocupe de nuevo este lenguaje. Y quien sabe que algún día
seamos inventores de algo que también revolucione nuestro mundo, como los inventores que ha
habido a lo largo de la historia.
31
Bibliografía
Análisis y diseño de circuitos lógicos digitales. Victor Nelson. 1ª edición. Prentice Hall.
http://personales.unican.es/manzanom/EdigitalI/MuxG7_09.pdf
http://www.fing.edu.uy/inco/cursos/arqsis/recursosLaboratorio/Tutorial.pdf
http://www.dea.icai.upco.es/sadot/ed-itei/tutorial-maxplus.pdf
http://es.wikipedia.org/wiki/Demultiplexor
http://www.cps.unizar.es/~te/Docencia_archivos/ldh_archivos/T4.pdf
http://www.dc.uba.ar/materias/oc1/2007/c2/practica/apuntes/vhdl
http://es.scribd.com/doc/2154178/UPM-Introduccion-al-lenguaje-VHDL
http://www.eweb.unex.es/eweb/fisteor/antonio_astillero/ec/vhdl/Manual%20VHDL.pdf