Sistemas Embebidos Resumen Octubre 2020 Febrero 2021

UNIVERSIDAD TÉCNICA DE AMBATO
FACULTAD DE INGENIERÍA EN SISTEMAS, ELECTRÓNICA E INDUSTRIAL

CARRERA DE TELECOMUNICACIONES
Cdla. Universitaria (Predios Huachi) / Casilla 334 / Telefax: 03-2851894 – 2411537, Correo Electrónico: carrera.industrial@uta.edu.ec
AMBATO-ECUADOR
1. PORTADA
FACULTAD DE INGENIERÍA EN SISTEMAS,

ELECTRÓNICA E INDUSTRIAL
CARRERA DE INGENIERÍA EN ELECTRÓNICA Y

COMUNICACIONES
Sistemas Embebidos
5to “A”
Resumen Parcial 1
Fecha de Entrega: 04 de Diciembre del 2020
Docente: Ing. Edgar Patricio Córdova Córdova
OCTUBRE 2020 - ENERO 2021
AMBATO - ECUADOR
2020
8
AMBATO-ECUADOR
2. INTRODUCCIÓN
En el presente documento se lleva a cabo la elaboración del resumen teórico y práctico que se
ha desarrollado en cada uno de los temas planteados dentro de las unidades de estudio, desde lo
que son los sistemas digitales hasta el estudio de diseño en VHDL y sistemas embebidos
mediante el uso de FPGA de National Instruments, todo esta recopilación cuenta con una gran
cantidad de información resumida de los temas antes mencionados, ejercicios propuestos por el
docente y ejercicios propuestos por los alumnos todos estos ejercicios cuentan con su respectiva
resolución, al final del mismo se podrá encontrar unos reactivos que ayudaran alumno a
comprender los temas correspondientes a la materia de Sistemas Embebidos (VLSI).
El estudio de los sistemas digitales abarca varios aspectos los cuales son fundamentales para el
desarrollo de estos; en los cuales se encuentran prioritariamente los sistemas digitales
combinacionales, secuenciales, autómatas finitos. Dentro de un sistema digital se encuentran los
micro dispositivos programables, los cuales se diferencian los microprocesadores y
microcontroladores a su vez se destaca la presencia de los sistemas digitales reconfigurables o
aquellos que utilizan FPGA.
Se define los modelos en los que puede ser contemplado un autómata finito, los cuales son, el
modelo de Mealy y de Moore. Estos toman importancia cuando son utilizados para diseñar
sistemas secuenciales síncronos, de tal manera que se permita aclarar las semejanzas
y diferencias entre ambos modelos. Presentamos la fundamentación teórica con explicaciones
concisas de las máquinas de estado, Tipos de detectores de códigos, señal Síncrona y Asíncrona,
y el proceso de diseño. Para los diseños se considera fundamental definir el tipo de detector de
código relacionado a los requerimientos presentados, si es continuo o segmentado
posteriormente el modelo del autómata Mealy o Moore.
Los modelos de Mealy y Moore se componen por una estructura diseño que establecen los
parámetros o guías que deben cumplir para ser implementados, a esto se lo denomina como
procesos de diseños, es parte esencial para la implementación empezamos diseñando el
diagrama de estados de acuerdo a los parámetros de inicio, la tabla de diseño que tiene su
relación con los datos del diagrama de estados, posteriormente encontramos las ecuaciones o
funciones de estados y procedemos a realizar su diagrama esquemático para posteriormente
realizar la simulación o implementación del circuito. una de las aplicaciones de los autómatas
finitos o maquinas secuenciales pueden ser utilizadas para desarrollar contadores complejos,
detectores de código a si también como generadores y analizadores de secuencia todo esto se
analiza con ejemplos prácticos para facilitar la comprensión de la utilidad de las maquinas
secuenciales.
El estudio de los microcontroladores abarca un sin números de actividades y temas por

descubrir sin embargo dentro de su programación se encuentran inmersos varios softwares que
interactuar entre ellos para poder realizar la comunicación por medio de archivos
ejecutables. Además de eso cabe mencionar que la programación para microcontroladores se
realiza en lenguaje C y su simulación en Proteus debido a que este software facilita el
aprendizaje y la metodología al momento de integrar herramientas como el simulador de
Proteus, compilador CCS C, lenguaje de programación C y por ende el dispositivo
microcontrolador, además muestra de una forma didáctica la manipulación de sus funciones
mediante Arduino IDE y de la misma manera con PIC C Compiler. De igual manera, se darán a
conocer dos ejercicios resueltos sobre el control básico de un motor DC donde se mostrarán las
programaciones en los Arduino y Pic C Compiler, con ayuda del software de simulación Proteus
se realizarán los circuitos para verificar su funcionamiento.
9
AMBATO-ECUADOR
También se detalla el uso de los sensores y los actuadores por lo que en este documento se va a
explicar cada uno de estos y sus principales características, debemos tener en cuenta
que sensorizar es un método por medio del cual recolectamos datos en tiempo real, así como
también podemos decir que los actuadores se componen de un conjunto de sensores, los cuales
poseen dispositivos de entrada y dispositivos de salida, se puede decir también que algunos
sensores necesitan hacer un procesamiento que se llama acondicionamiento de señal y se puede
realizar por medio de software o hardware.
Dentro de lo que son las comunicaciones, haciendo énfasis en los temas ya referidos
anteriormente. Es importante conocer cada uno de estos ya que cada uno presta diferente
funcionalidad, de esta manera son capaces de satisfacer cualquier tipo de circuito digital que se
requiera. Además, se definirá cada uno de los temas, las características, como es le
comunicación y como funciona cada uno de ellos. Así también como se realiza las simulaciones,
en Arduino, proteus y Pic C Compiler con la respectivas Librerías.
El estudio de comunicación inalámbrica abarca grandes temas y conceptos fundamentales para

el desarrollo de circuitos por medio del uso de microcontroladores. En comunicación
inalámbrica se cubre grandes definiciones y tipo de comunicaciones inalámbricas como:
Wifi, Zygbee, Bluetooth. En base a esto también se verán los conceptos de comunicación
inalámbrica Wifi enfocada a la conexión con microcontroladores. Además de
que mostrarán ejemplos de comunicación inalámbrica haciendo uso de la comunicación con
Bluetooth con microcontroladores.
Se dice que el lenguaje de Descripción de Hardware (HDL) es un lenguaje de programación

eficiente creada para poder definir estructuras, diseños y operaciones en circuitos electrónicos,
con esto hacemos posibles a lo que viene siendo el análisis automático y posteriormente su
respectiva simulación.
VHDL es un lenguaje de descripción de circuitos electrónicos digitales que pueden ser

simulados utilizando una serie de herramientas las cuales tratar de generar dichos circuitos con
puertas lógicas, también se define como un lenguaje de descripción de hardware con el cual
vamos creando nuestros circuitos en base a la sintaxis aprobada por la IEEE para lo que son los
circuitos descriptivos.
Cada uno de estos de diferencias por sus características las cuales tenemos como son la
jerarquía, soporte, diseño genérico, concurrencia, estilos de descripción, estructura entre otras.
Y son muy utilizadas en lo que viene siendo sistemas embebidos.
Los circuitos Integrados Digitales programables están desarrollados con componentes lógicos y
aplicaciones digitales más complejas, las herramientas de diseños van cambiando a través del
tiempo dejando obsoletas e ineficientes, por lo cual, desarrollan herramientas más útiles,
originándose así los HDL más conocidos como Lenguajes de Descripción de Hardware y dentro
de esto se encuentra los VHDL, el IEEE desarrollan el lenguaje VHDL que viene de VHSIC
HDL, o sea Lenguaje de Descripción de hardware para circuitos integrados de muy alta
velocidad. Este lenguaje de descripción de hardware es una herramienta que permite describir la
estructura y comportamiento de un sistema para lograr una especificación, documentación y
simulación del mismo antes de su realización real.
La metodología Top-Down de diseño de circuitos electrónicos contiene procesos de capturar

una idea en un alto nivel de abstracción e implementarla partiendo de esta descripción abstracta
y después ir hacia abajo incrementando el nivel de detalle según sea necesario, en
contraposición a la metodología bottom-up, llevó a la aparición de herramientas de descripción
10
AMBATO-ECUADOR
que permiten al diseñador definir el problema de una forma abstracta, utilizando a los
ordenadores para materializar la idea empleada.
Explicaremos los ejercicios planteados en clase, en los cuales realizamos los circuitos como un
convertidor, un mod 16 además de estos también realizamos un sumador con características
simples también realizamos un mod 10 y además de esto un detector de código, estos ejercicios
serán explicados paso a paso en el siguiente documento, para comprender de mejor manera los
ejercicios propuestos en clase también realizaremos y diseñaremos ejercicios propuestos con los
cuales se explicara de mejor manera el funcionamiento del programa ISE Desing Suite.
El diseño de una lógica programable en VHDL sigue un flujo de diseño el cual está compuesto
por: la entrada de diseño que corresponde a la descripción del sistema a implementar el cual se
inicializar las entradas y salidas de variables a utilizar y en la arquitectura realizar el modelado
de acuerdo a las condiciones de funcionamiento del sistema digital a implementar, la síntesis
que permite realizar una revisión de sintaxis del código fuente el cual genera un reporte de
advertencias y errores en caso de existir, banco de prueba (Test Benc Module) sirvepara poder
simular el circuito en donde se definen los variables y estímulos (señales de reloj, contadores,
bits, etc. ) de entrada, las salidas serán en función del circuito
11
AMBATO-ECUADOR
3. ÍNDICE GENERAL
1. PORTADA ................................................................................................................................... 8
2. INTRODUCCIÓN ....................................................................................................................... 9
3. ÍNDICE GENERAL .................................................................................................................. 12
4. GLOSARIO DE TÉRMINOS .................................................................................................... 15
1. Sistemas Digitales ................................................................................................................... 15
2. Autómatas Finito ..................................................................................................................... 15
3. Detectores de Código .............................................................................................................. 16
4. Microcontroladores ................................................................................................................. 16
5. Librerías, Fusibles e Interrupciones. ......................................................................................... 9
6. Comunicaciones ........................................................................................................................ 8
7. Comunicación Inalámbrica Wifi ............................................................................................... 8
8. Proceso de programación HDL y VHDL. ................................................................................. 9
9. Modelos y Metodología de Diseño ........................................................................................... 8
5. DESARROLLO POR TEMAS .................................................................................................... 8
a. Fundamentación Teórica ........................................................................................................... 8
1. Sistemas Digitales ..................................................................................................................... 8
2. Autómatas finitos .................................................................................................................... 12
Máquinas de Mealy ........................................................................................................................ 16
Máquina de Moore ......................................................................................................................... 16
Librerías, Fusibles e Interrupciones ............................................................................................... 29
4. Control DIO, AIO, Sensores y Actuadores ............................................................................. 35
5. Comunicaciones ...................................................................................................................... 39
6. Comunicación Inalámbrica Wifi ............................................................................................. 47
7. Modelos y Metodología de Diseño VHDL ............................................................................. 54
8. Creación de un Proyecto ......................................................................................................... 63
10. Convertidor de código ............................................................................................................. 71
MODELADO ESTRUCTURAL ............................................................................................... 72
Componentes de una descripción estructural .......................................................................... 72
Procesos de instanciación........................................................................................................... 73
Instanciación directa................................................................................................................. 73
Declaración de componentes ......................................................................................................... 74
Atributos – Uso de Event para señal CLK ..................................................................................... 75
Sistemas Embebidos con dispositivos FPGA con National Instruments ....................................... 77
12
AMBATO-ECUADOR
Equipos DE (Digital Electronic) FPGA board NI ......................................................................... 81

4. Organizadores Gráficos de Resumen ......................................................................................... 91
1. Sistemas Digitales ................................................................................................................... 91
2. Autómatas Finitos ................................................................................................................... 95
3. Detectores de Código .............................................................................................................. 97
5. Librerías, Fusibles e Interrupciones ...................................................................................... 100
6. Control DIO, AIO, Sensores y Actuadores ........................................................................... 101
7. Comunicaciones .................................................................................................................... 103
8. Comunicación inalámbrica Wifi .............................................................................................. 107
9. Métodos Y Metodología de Diseño de Vhdl ........................................................................ 108
10. Creación de Proyecto......................................................................................................... 111
12. Sistemas Embebidos con dispositivos FPGA.................................................................... 115
5. ejercicios Resueltos .................................................................................................................. 118
1. Sistemas Digitales ...................................................................¡Error! Marcador no definido.
2. Autómatas Finitos ...................................................................¡Error! Marcador no definido.
3. Detectores de Código .............................................................. ¡Error! Marcador no definido.
4. Microcontroladores .................................................................¡Error! Marcador no definido.
5. Librerías, Fusibles e Interrupciones ........................................¡Error! Marcador no definido.
6. Control DIO, AIO, Sensores y Actuadores ............................. ¡Error! Marcador no definido.
7. Comunicaciones ......................................................................¡Error! Marcador no definido.
8. Comunicación inalámbrica Wifi .............................................¡Error! Marcador no definido.
9. Creación de Proyectos ............................................................................................................. 69
10. Convertidor de código ......................................................................................................... 78
Ejercicio en clase 1 .................................................................................................................... 78
11. Ejercicios Propuestos .............................................................. ¡Error! Marcador no definido.
1. Sistemas Digitales .....................................................................¡Error! Marcador no definido.
2. Autómatas Finitos ...................................................................¡Error! Marcador no definido.
3. Detectores de Código .............................................................. ¡Error! Marcador no definido.
Resultados .................................................................................¡Error! Marcador no definido.
4. Microcontroladores .................................................................¡Error! Marcador no definido.
5. Librerías, Fusibles e Interrupciones ........................................¡Error! Marcador no definido.
6. Control DIO, AIO, Sensores y Actuadores ............................. ¡Error! Marcador no definido.
7. Comunicaciones ......................................................................¡Error! Marcador no definido.
8. Comunicación Inalámbrica Wifi .............................................¡Error! Marcador no definido.
9. Proceso de programación HDL Y VHDL. .............................. ¡Error! Marcador no definido.
10. Creación de Proyectos ........................................................ ¡Error! Marcador no definido.
11. Convertidor de código ....................................................................................................... 148
13
AMBATO-ECUADOR
Ejercicio propuesto 1 ................................................................................................................... 148

1. CUESTIONARIO .................................................................................................................... 170
1. Sistemas Digitales .................................................................................................................... 170
2. Autómatas Finitos ................................................................................................................. 174
3. Detectores de Código ............................................................................................................ 176
4. Microcontroladores ............................................................................................................... 178
5. Librerías, Fusibles e Interrupciones ...................................................................................... 180
6. Control DIO,AIO, Sensores y Actuadores ............................................................................ 183
7. Comunicaciones .................................................................................................................... 185
8. Comunicación Inalámbrica Wifi ........................................................................................... 188
9. Proceso de programación HDL y VHDL. ............................................................................. 190
10. Metodos Y Metodologia de Diseño de VHDL .................................................................. 193
11. Desarrollo por temas ............................................................................................................. 193
12. Convertidor de código ....................................................................................................... 196
Reactivo 1. ....................................................................................................................................... 203
Reactivo 2. ................................................................................................................................... 204
Reactivo 3. ................................................................................................................................... 205
Reactivo 4. ................................................................................................................................... 205
14
AMBATO-ECUADOR
4. GLOSARIO DE TÉRMINOS
1. Sistemas Digitales
CONVERSOR: Dispositivo electrónico capaz PAL: Clase de dispositivos lógicos

de realizar transformaciones de señales análogas programables. Su matriz AND es programable,
como la corriente o tensión, a señales digitales. mientras que su matriz OR es fija [1].
CLK: Señal digital la cual es configurable el PLA: Por sus siglas en inglés como
ancho de pulso periodo y flancos de subida y "Programmable Logic Array" o Arreglo Lógico
bajadas, capaces se satisfacer acciones a varios Programable [1].
circuitos en el mundo digital. RAM: Memoria de Acceso Aleatorio es una
Señal Reloj: Es una señal cuadrática (En la cual memoria en la cual el
el tiempo de subida puede o no ser igual al tiempo de acceso es el mismo para cualquier
tiempo de bajada) [1]. ubicación [1].
CPLD: Es un PLD Complejo Clase de PLDs ROM: Memoria de Sólo Lectura es un
que contiene una matriz de bloques tipo PAL, dispositivo de memoria diseñado para
los cuales pueden interconectarse [1]. aplicaciones en donde la relación de
ESTADO: Es un conjunto de valores que tienen operaciones de lectura con las operaciones de
las variables de entrada, los procesos y las escritura es muy alta [1].
salidas. Es el espacio definido entre dos SEÑAL RELOJ: Es una señal cuadrática (En la
transiciones [1]. cual el tiempo de subida puede o no ser igual al
FPGA: Clase de PLDs que contiene una matriz tiempo de bajada) [1].
de celdas lógicas más complejas, las cuales VHDL: Lenguaje de descripción de hardware
pueden interconectarse en forma muy flexible desarrollado por el Departamento de Defensa de
para implementar circuitos lógicos de alto nivel Estados Unidos para documentar, simular y
[1]. sintetizar sistemas digitales complejos [1].
GAL: Por sus siglas Arreglo Genérico HDL: Lenguaje de Descripción de Hardware
Programable es un dispositivo que es (HDL) Método basado en texto para describir el
básicamente una PAL que puede reprogramarse hardware digital que sigue una determinada
muchas veces [2]. sintaxis para representar objetos de datos y
estructuras de control [1].
2. Autómatas Finito
DIAGRAMA DE ESTADOS: Muestra la PRÓXIMO ESTADO: El estado al que irá la

forma y la función de la máquina de estados. máquina de estados en la siguiente transición (se
Normalmente un diagrama de círculos y flechas. produce por la señal de reloj). [5]
[2] RAMA: Indica un cambio del estado presente al
ESTADO: Es un conjunto de valores que tienen próximo estado. [5]
las variables de entrada, los procesos y las TABLA DE TRANSICIÓN: También llamadas
salidas. Es el espacio definido entre dos tablas características, las tablas de estados de
transiciones. [3] una dimensión son más como tablas de verdad
MÁQUINA DE MEALY: Una máquina Mealy que como las versiones de dos dimensiones. Las
es una máquina de estado finito cuyos valores entradas son normalmente colocadas a la
de salida están determinados tanto por su estado izquierda, y separadas de las salidas, las cuales
actual como por las entradas actuales. Esto están a la derecha. Las salidas representarán el
contrasta con una máquina Moore, cuyos siguiente estado de la máquina. [5]
valores de salida están determinados únicamente AUTÓMATAS FINITOS: Un autómata finito
por su estado actual. [2] (AF) o máquina de estado finito es un modelo
SEÑAL RELOJ: Es una señal cuadrática (En la computacional que realiza cómputos en forma
cual el tiempo de subida puede o no ser igual al automática sobre una entrada para producir una
tiempo de bajada) salida. [5]
15
AMBATO-ECUADOR
MÁQUINA DE MOORE: Una máquina Moore SEGMENTADO: Denominado también como

es una máquina de estado finito cuyos valores detector de secuencia sin superposición, en el
de salida están determinados solo por su estado cual el último bit de una secuencia no se
actual. Esto contrasta con una máquina Mealy, convierte en el primer bit de la secuencia
cuyos valores de salida están determinados tanto siguiente aquí se restablece al estado de inicio
por su estado actual como por los valores de sus cuando se ha detectado la secuencia. [2]
entradas. [2] CONTINUO: También denominado detector de
TRANSICIÓN: Es el cambio de un estado a secuencia con superposición es un detector de
otro. [4] secuencia que permite la superposición, los bits
finales de una secuencia pueden ser el comienzo
de otra secuencia [2]
3. Detectores de Código
SÍNCRONO: Lo que tiene un intervalo de CONTADOR DE CICLOS: Está diseñado

tiempo constante entre cada acción. [6] para monitorear con precisión el número de
RETROALIMENTACIÓN: Retorno de parte ciclos de su molde y ayuda en el proceso
de la energía o de la información de salida de un general de mantenimiento del molde. [9]
circuito o un sistema a su entrada. [7] CÓDIGO: Sistema de signos y de reglas que
CLK: En electrónica y especialmente en permite formular y comprender mensajes
circuitos digitales síncronos, una señal de reloj secretos. [7]
es una señal usada para coordinar las acciones SEGMENTO: Porción o parte cortada o
de dos o más circuitos. [8] separada de una cosa, de un elemento
ANALIZADORES: Anteojo del geométrico o de un todo. [7]
espectroscopio con que se observa la luz ya
dispersada. [7]
4. Microcontroladores
ARDUINO: Plataforma de desarrollo de IDE: Entorno de desarrollo Integrado.

proyectos de microelectrónica. MICROCONTROLADOR: Dispositivo o
DIGITAL: Es aquella que toma un conjunto de tarjeta programable que permite efectuar
valores. ordenes o instrucciones pregrabadas dentro del
LENGUAJE DE PROGRAMACIÓN: mismo.
conjunto de instrucciones que permiten generar MICROPROCESADOR: Es un circuito
órdenes a un microcontrolador. integrado digital de muy gran escala que puede
COMPILER: Ejecución de un programa o ser programado para realizar operaciones
línea de instrucción. aritméticas, lógicas u otras.
PLATAFORMA: Pagina web que contiene CONVERSIÓN: Cambio de unidades de
información digitalizada educativa o acuerdo con el sistema de medidas
empresarial, que brindan instrucciones de INTERFAZ: Mecanismo por el que los dos o
conocimientos para un mejor desarrollo más dispositivos electrónicos o sistemas se
personal o profesional. hacen compatibles mediante una interconexión.
CÓDIGO: Algoritmo de combinaciones PUERTO: Es una interfaz física en una
número o alfabéticas que permiten dar o negar computadora, a través de la cual se transfieren
acceso a software determinado. datos hacia o desde un periférico.
SOFTWARE: Parte intangible que forma parte PROCESSING: Intervalo de tiempo donde el
de un ordenador. software recepta la información para
HARDWARE: Parte Tangible que del posteriormente dar una respuesta acorde a las
16
AMBATO-ECUADOR
ordenador o computador. instrucciones de entrada.

RETARDO: Es el intervalo de tiempo entre la DISPOSITIVOS: Son instrumentos
aplicación. tecnológicos utilizados en la sociedad.
de un impulso de entrada y la aparición del
impulso de salida resultante.
MICROCHIP: Circuito digital (dispositivo)
que convierte la información codificada en un
formato más familiar o no codificado.
5. Librerías, Fusibles e Interrupciones.
ARDUINO: es una plataforma de desarrollo BITS: Unidad mínima de información, que

basada en una placa electrónica de hardware puede tener solo dos valores [11].
libre que incorpora un microcontrolador Control DIO, AIO, Sensores y Actuadores
reprogramable y una serie de pines hembra [10]. SEÑAL DIGITAL: señal que existe en uno de
ATMEGA: Es el microcontrolador más común dos estados encendida o apagada [1].
e utilizado en Arduino [2]. SEÑAL ANALOGA: Es aquella que los
PIC C COMPILER: Es un inteligente y muy valores de voltaje varían en relación con el
optimizado compilador C que contienen tiempo y pueden tomar cualquier valor [2].
operadores estándar del lenguaje C y funciones SENSOR: dispositivo cuya función es detectar
incorporados en bibliotecas que son específicas magnitudes que pueden ser físicas o químicas o
a los registros de PIC, proporcionando a los también llamadas variables [3].
desarrolladores una herramienta poderosa para PRESICION: es el error de medida máximo
el acceso al hardware las funciones del esperado [2].
dispositivo desde el nivel de lenguaje C [11]. OFFSET: valor de la variable de salida cuando
MICROCONTROLADOR: Es un circuito la variable de entrada es nula [2].
integrado programable, capaz de ejecutar las RESOLUCION: mínima variación de la
órdenes grabadas en su memoria. Está magnitud de entrada que puede detectarse a la
compuesto de varios bloques funcionales que salida [2].
cumplen una tarea específica [2]. RAPIDEZ DE RESPUESTA: puede ser un
HARDWARE: Conjunto de elementos físicos tiempo fijo o depender de cuánto varíe la
o materiales que constituyen una computadora o magnitud a medir [2].
un sistema informático [11]. DERIVAS: son otras magnitudes, aparte de la
SOFTWARE: Conjunto de programas y medida como magnitud de entrada, que influyen
rutinas que permiten a la computadora realizar en la variable de salida [2].
determinadas tareas [11]. REPETITIVIDAD: error esperado al repetir
varias veces la misma medida [2].
9
6. Comunicaciones
CONVERSOR: Dispositivo electrónico capaz BLUETOOTH: es una especificación

de realizar transformaciones de señales análogas tecnológica para redes inalámbricas que
como la corriente o tensión, a señales digitales. permite la transmisión de voz y datos entre
[12] distintos dispositivos mediante una
PRI es el tiempo entre pulsos secuenciales. Por radiofrecuencia segura (2,4 GHz). Esta
lo general, medimos el PRI como el tiempo tecnología, por lo tanto, permite las
desde el comienzo de un pulso y el comienzo del comunicaciones sin cables ni conectores y la
siguiente. [12] posibilidad de crear redes inalámbricas
PWM modulación de ancho de pulsos es una domésticas para sincronizar y compartir la
salida rápida que oscila entre el apagado y el información que se encuentra almacenada en
encendido en un ciclo de servicio ajustable, que diversos equipos. [14]
produce una forma de onda rectangular. [12] PRESCALER: determina el tiempo de
HALF – DÚPLEX: Permite la transmisión en interrupción. [13]
ambos sentidos de manera alterna. Un ejemplo PRF es el recíproco del PRI. La unidad de
de este tipo son las transmisiones efectuadas por medida básica para PRF es hercios (Hz).
radioaficionados. [12] Utilice PRF para informar el número de pulsos
COMPARAR: Compara el valor del por segundo. [6]
temporizador con el valor de un registro y I2C son protocolos que pueden vincular un
provoca una acción en el PIC. [13] microordenador con otros micros o de circuitos
COMUNICACIÓN SERIAL integrados. [6]
SINCRÓNICA: Se requiere adicionar una línea SÍMPLEX: En este modo solo es posible la
que contenga pulsos de reloj que indiquen que el transmisión en un sentido, del terminal que
dato que viaja en la otra línea de datos es válido; origina la información hacia el que la recibe y
la duración del bit está determinada por la procesa. [12]
duración del pulso de sincronismo. [6] CLK: Es una señal cuadrática (En la cual el
POSTCALER: es un número de 1-16 que dice tiempo de subida puede o no ser igual al tiempo
cuántas veces el Timer2 tiene que desbordarse de bajada) [1].
para llamar a la interrupción [13]
7. Comunicación Inalámbrica Wifi
WIFI: es una tecnología que permite la MCU: Microcontrolador

interconexión inalámbrica de dispositivos IOT: Internet de las Cosas
electrónicos [1]. IIOT: Internet de las Cosas
BLUETOOTH: Es una especificación ETHERNET: Es un estándar de redes de área
industrial para redes inalámbricas de área local para computadoras, por sus siglas en
personal (WPAN) creado por Bluetooth Special español Acceso Múltiple con Escucha de
Interest Group, Inc. que posibilita la transmisión Portadora y Detección de Colisiones
de voz y datos entre diferentes dispositivos (CSMA/CD) [5].
mediante un enlace por radiofrecuencia en la NODEMCU: un firmware basado en Lua [1].
banda ISM de los 2.4 GHz [1]. ARDUINO: un firmware basado en C ++. Este
COMUNICACIÓN INALÁMBRICA: Es núcleo permite que la CPU ESP8266 y sus
aquella en la que extremos de la comunicación componentes Wi-Fi sean programados como
(emisor/receptor) no se encuentran unidos por cualquier otro dispositivo Arduino. El Arduino
un medio de propagación físico, sino que se Core ESP8266 está disponible a través de
utiliza la modulación de ondas GitHub [1].
electromagnéticas a través del espacio [1]. MICROPYTHON: una implementación de
WLAN: Wireless local area network [2]. Python para dispositivos embebidos a la
IEEE: Instituto de Ingenieros Eléctricos y plataforma ESP8266 [1].
Electrónicos. ESP8266 BASIC: Un intérprete básico de
WIFI ALLIENCE: Es una organización que código abierto específicamente diseñado para el
promueve la tecnología Wi-Fi y certifica los Internet de las cosas [1].
productos Wi-Fi, si se ajustan a ciertas normas MONGOOSE FIRMWARE: Un firmware de
de interoperabilidad [1]. código abierto con servicio gratuito en la nube
PUNTO DE ACCESO: Crea un punto de [1].
acceso a Internet donde no lo hay. Podríamos DMA: Acceso directo a memoria.
decir que se trata de una ampliación del router, RCIS: Computación de conjunto de
crear un "segundo router" para ofrecer mejor Instrucciones reducido
conectividad donde el router principal no llega GPIO: Entrada/Salida de Propósito General.
[3]. WPA: Acceso Wi-Fi protegido
ROUTER: Se trata del aparato que
normalmente las operadoras colocan en el hogar
cuando se contrata un servicio de Internet [3].
RED AD-HOC: es un tipo de red inalámbrica
descentralizada. La red es ad hoc porque no
depende de una infraestructura preexistente,
como routers (en redes cableadas) o de puntos
de accesos en redes inalámbricas administradas
[4].
8. Proceso de programación HDL y VHDL.
HDL: Lenguaje de Descripción de Hardware del software que conecta con la elaboración de
(HDL) Método basado en texto para describir el páginas web en sus diferentes versiones, define
hardware digital que sigue una determinada una estructura básica y un código (denominado
sintaxis para representar objetos de datos y código HTML). [1]
estructuras de control.[1] LAMP SERVER: LAMP server es un
VHDL: Lenguaje de descripción de hardware protocolo que permite crear una interfaz web a
desarrollado por el Departamento de Defensa de través de cuatro herramientas importantes:
Estados Unidos para documentar, simular y servidor de apache, My sql y php todos estos en
sintetizar sistemas digitales complejos. [1] base al sistema operativo Linux.[1]
FPGA: Estos son unos diminutos dispositivos BASE DE DATOS: Una base de datos permite
semiconductores que tienen la capacidad de almacenar gran número de información de una
programarse para realizarse acciones muy forma organizada para su futura consulta,
concretas de forma rápida y eficiente.[1] realización de búsquedas, nuevo ingreso de
ENTIDAD: Una entidad es la abstracción de un datos, etc. [1]
circuito, ya sea desde un complejo sistema IDE: Un entorno de desarrollo integrado (IDE)
electrónico o una simple puerta lógica. [1] es un sistema de software para el diseño de
ARQUITECTURA: Una arquitectura describe aplicaciones que combina herramientas del
el funcionamiento de la entidad a la que hace desarrollador común en una sola interfaz gráfica
referencia el funcionamiento de la entidad a la de usuario (GUI). [1]
que está asociada utilizando las sentencias y
expresiones propias de VHDL. [1]
HTML: Es un estándar que sirve de referencia
9. Modelos y Metodología de Diseño
HDL: Es un lenguaje de programación mediante componentes que pueden agruparse

especializado que se utiliza para definir la en diferentes módulos, y éstos últimos a su vez
estructura, diseño y operación de circuitos en otros módulos hasta llegar a representar el
electrónicos y electrónicos digitales [15]. sistema completo que se desea implementar
VHDL: Es un lenguaje de descripción de [17].
circuitos electrónicos digitales que utiliza SUBSISTEMA: Es un conjunto de elemento
distintos niveles de abstracción [16]. interrelacionados que, en sí mismo, es un
ENTITY: Una entidad es la abstracción de un sistema, pero a la vez es parte de un sistema
circuito, ya sea desde un complejo sistema superior. [18]
electrónico o una simple puerta lógica [16]. TOP-DOWN: Es el diseño que consiste en
ARCHITECTURE: Una arquitectura capturar una idea con un alto nivel de
describe el funcionamiento de la entidad a la abstracción, implementarla partiendo de la
que hace referencia, es decir, dentro de misma, e incrementar el nivel de detalle según
architecture tendremos que describir el sea necesario [17].
funcionamiento de la entidad a la que está TEST BENCH: conjunto elementos
asociada utilizando las sentencias y utilizados para probar un diseño. El concepto
expresiones propias de VHDL [16]. se basa en la analogía con un banco de pruebas
PROCESS: Es una estructura particular de físico, utilizado para verificar el
VHDL que se reserva principalmente para funcionamiento de un dispositivo. [19]
contener sentencias que no tengan MULTINIVEL: Debe poseer la capacidad de
obligatoriamente que tener definido su valor utilizar el rango más amplio posible de niveles
para todas las entradas. y de especificaciones. [20]
ALIAS: Es una manera alternativa de NETLIST: Es el término utilizado para
nombrar a un elemento ya existente [16]. describir un archivo generado por los
OPERADOR: Un operador nos permite programas de diseño electrónico (CAD), que
construir diferentes tipos de expresiones contiene un listado de las conexiones
mediante los cuales podemos calcular datos o Nets eléctricos que existen entre
utilizando diferentes señales [16]. los terminales de los componentes que
SÍNTESIS LÓGICA: Convierte una pertenecen a un circuito esquemático o
descripción de un sistema digital mediante un un PCB. [21]
HDL en una implementación tecnológica [16].
BOTTOM-UP: Es la metodología de diseño SUBPROGRAMAS: son rutinas,
que comprende la descripción del circuito procedimientos o conjuntos de instrucciones
que realizan una labor específica. permiten la
descomposición de un problema complejo en
subproblemas más sencillos abordables de
forma independiente. [22]
10. Convertidor de Código
ESTRUCTURA: Modo de estar organizadas ARQUITECTURA: La arquitectura de

u ordenadas las partes de un todo. [23] software es un conjunto de patrones que
proporcionan un marco de referencia necesario
ENTIDAD: Una entidad es un objeto para guiar la construcción de un software [23]
concreto o abstracto que presenta interés para
el sistema y sobre el que se recoge FPGA: Una matriz de compuerta programable
información la cual va a ser representada en en campo es un circuito integrado diseñado
un sistema de base de datos. [23] para ser configurado por un cliente o un
diseñador después de la fabricación, de ahí el
término "programable en campo [24]
ISE DESING SUIT: ISE Desing es una
herramienta de software de Xilinx que ofrece
el análisis de diseños HDL en el cual permite
desarrollar circuitos profesionales, análisis de
tiempos, entornos de programación,
simulaciones de comportamiento de un diseño
para satisfacer las necesidades de diseño del
programador. [25]
VHDL: VHDL es un lenguaje de descripción
de hardware utilizado en la automatización de
diseño electrónico para describir sistemas de
señales digitales y mixtas, como arreglos de
puertas programables en campo y circuitos
integrados. VHDL también se puede utilizar
como lenguaje de programación paralelo de
uso general. [24]
ISE: Software de Xilinx.
XILINX: Xilinx, Inc. es una compañía de
tecnología estadounidense que desarrolla
plataformas de procesamiento altamente
flexibles y adaptativas. La compañía inventó
la matriz de compuerta programable en
campo, el sistema en chips programable y la
plataforma de aceleración de cálculo
adaptativa [25]
CODIGO: Es un conjunto de reglas, o una
serie de símbolos que por separado no
representan nada, pero al combinarlos pueden
generar un lenguaje comprensible solo para
aquellos quienes lo entiendan [1]
CONVERTIDOR DE CODIGO: Es un
elemento lógico que traduce una palabra de
“n” bits a otra de “m” bits, las cuales se
refieren al mismo valor decimal, pero en
distintos códigos. [1]
5. DESARROLLO POR TEMAS
a. Fundamentación Teórica
Un sistema digital es el conjunto de dispositivos para el procesado de señales físicas que
serán convertidas en señales digitales es decir señales con valores discretos. El sistema consta
de tres etapas en todo el procesado de datos [1]:
Entrada (señal física); Proceso (procesamiento de datos); Salida (datos en formato digital)
[Cando. E, Contreras. S, Pérez. C, Soto. D].
Ilustración 1.- Entrada, Proceso, Salida de un sistema digital [26].
Su representación viene a ser dado mediando algebra booleana [Cando. E, Contreras. S,

Pérez. C, Soto. D].
Ilustración 2.- Representación viene a ser dado mediando algebra booleana [26].
Sistemas Combinacionales
En este tipo de sistema digital la salida es dependiente de la combinación de sus entradas.
Se destaca por la ausencia de la señal Reloj, es decir no tienen estados [1].
El modelo matemático representativo de los sistemas combinacionales es [1]:
Ilustración 3.- Ecuación Sistemas Combinacionales
Sistemas Digitales Secuenciales
“Un circuito secuencial es un tipo de circuito lógico. Envía una salida que depende de la
entrada actual, además de la historia de la entrada” [5]; es decir, es cuando el nivel lógico de
la salida depende de los estados. Este tipo de sistemas necesitan de una memoria y una señal
de reloj (CLK) [Cando. E, Contreras. S, Pérez. C, Soto. D].
Modelo matemático
𝒚 = 𝒇(𝑸𝒄𝒍𝒌)
Una característica importante en los sistemas secuenciales es que, estos no poseen entradas
[Cando.E, Contreras.S, Pérez.C, Soto.D].
Síncrono
La señal de reloj afecta a todas las etapas del circuito al mismo tiempo; entender de mejor
manera este sistema se presenta en la siguiente imagen [5]:
Ilustración 4.- Sistema digital síncrono [5].
Asíncrono
Sus variables de estados no cambian simultáneamente. Y hay que recordar que la señal de
reloj sólo se aplica al 1er biestable, para entender de mejor manera este sistema se presenta en
la siguiente imagen [5]:
Ilustración 5.- Sistema digital asíncrono
Autómatas Finitos
También conocidos como máquinas secuenciales, este tipo de sistemas se caracterizan por el
hecho de que su salida no sólo depende de los estados sino también del valor lógico de las
entradas del sistema. Se les denomina [1]:
Modelo matemático
𝒚 = 𝒇(𝒙, 𝑸𝒄𝒍𝒌)
Es importante conocer que existen 2 tipos de máquinas secuenciales:
• Autómata Finito de Mealy

• Autómata Finito de Moore
Un autónomo finito cuenta de tres etapas:
1. Sistemas combinacionales de entrada [1].

2. Memoria o Maquina de Estado [1].
3. Sistema combinacional de salida [1].
De la variación de esta estructura se obtienen los Modelos de Mealy y de Moore, a

continuación, presentada en la siguiente imagen [1]:
Ilustración 6.- Etapas autómatas finitos [1].
Micro Dispositivo
Es un microprocesador puede llevar a cabo operaciones aritméticas y lógicas, desplazar datos
de un lugar a otro y tomar decisiones basándose en ciertas instrucciones [5].
Micro Dispositivo (Programables)
Microprocesador
Es aquel dispositivo cuyo propósito es solventar las exigencias del usuario mediante su
previa programación; este dispositivo está limitado por su arquitectura a su vez es de
carácter abierta la cual le permite jugar con sus componentes; entender de mejor manera el
funcionamiento de un microprocesador se presenta en la siguiente imagen [5]:
Ilustración 7.- Funcionamiento Microprocesador [5].
Microcontrolador
Es aquel dispositivo que se encarga de recibir información desde los periféricos de entrada
y enviar por los periféricos de salida, a su vez consta de una arquitectura cerrada la cual no
le permite jugar con los componentes entender de mejor manera el funcionamiento de un
microprocesador se presenta en la siguiente imagen [5] .
Ilustración 8.- Funcionamiento Microcontrolador [5].
Proceso de programación y ejecución

Es la secuencia de pasos que se realizan para la ejecución del programa por medio del
microcontrolador, el cual ejecutara las instrucciones de manera secuencial [Cando. E,
Contreras. S, Pérez. C, Soto. D].
Ilustración 9.- Proceso de programación y ejecución.
Lenguaje de Programación: Un lenguaje para transmitir a la máquina las órdenes que se le

quieren dar; y una manera de pensar y concebir dar órdenes a la computadora [26].
Interfaz de transferencia (Hardware): Se encarga de gestionar todo el proceso de
programación con el cual el microcontrolador pueda ejecutar el programa [Cando. E,
Contreras. S, Pérez. C, Soto. D].
Sistemas Digitales reconfigurables

Los Sistemas reconfigurables son aquellos que utilizan FPGA; son sistemas que pueden
cambiar su configuración interna, estos se construyen con arreglos de compuertas lógicas
[Cando. E, Contreras. S, Pérez. C, Soto. D].
Ilustración 10.- Sistemas Digitales reconfigurables
2. Autómatas finitos
Máquina de Mealy
Definición
Una máquina Mealy es una máquina de estado finito cuyos valores de salida están
determinados tanto por su estado actual como por las entradas actuales [2]
Esquema
El autómata finito de Mealy es un tipo de máquina de estados finitos en el cual se obtiene una
salida en cada transición de la combinación de su estado interno y una entrada definida. [27]
Ilustración 11 Esquema básico de la máquina de Mealy
Diagrama de estado
Desarrollando diagramas de manera manual o con el uso del software de simulación Boole
Deusto observando sus transiciones de secuencia en base al tipo de detector de código [1]
Ilustración 12 Diagrama de estados Mealy

Tabla de transición
A esta tabla también se la llama matriz de transiciones. En las columnas se indican los
diferentes valores que puede tomar la entrada. En los renglones se indican los estados
internos actuales. En cada casillero de la matriz, se indica el próximo estado y la salida
asociada. La matriz suele representarse como un mapa de Karnaugh.
Máquina de Moore
Definición
Es una máquina de estado finito cuyos valores de salida están determinados solo por su
estado actual. [2]
Esquema
Toda máquina finita de Moore es una definición alternativa de máquinas secuenciales en los
cuales los valores de salida en un momento dado no dependerán solo de los valores de
entrada, si no también dependerá del estado anterior, en este caso la función de salida solo
depende del estado en el que este se encuentre [26]
Ilustración 13 Esquema básico de la máquina de Moore
Diagrama de estado
Desarrollando diagramas de manera manual o con el uso del software de simulación Boole
Deusto observando sus transiciones de secuencia en base al tipo de detector de código. [27]
Ilustración 14 Diagrama de estados Moore
Diseño de Autómatas Finitos
Para el diseño de los autómatas finitos se debe considerar los siguientes aspectos:
Aspectos para considerar
➢ Características de operación
Comenzamos con la declaración formal del problema, estableciendo exactamente lo
que nos solicita el enunciado
➢ Modelo de la máquina
Esto implica el tipo de modelo que se diseñara ya sea Mealy o Moore
Proceso de Diseño
➢ Diagrama de estados: Mediante el diagrama de estados se puede generar:

- Tabla de transición de entradas y salidas
- Tabla de simulación de secuencia
➢ Tabla de diseño: En esta etapa se tendrá en consideración entrada, estados y salidas,
para poder desarrollar tablas de excitación de transición.
➢ Funciones de estados y salida
➢ Diagrama esquemático: Se puede realizar en los softwares de simulación (Boole
Deusto y Proteus) logrando tener una noción de lo que sucederá en forma física. [5]
Tabla de diseño (Sistemas Síncronos)
Mealy
La salida va a depender tanto de la entrada como del estado
Moore
La salida depende solo del estado
Aplicaciones de autómatas finitos
➢ Contadores complejos
➢ Generadores y analizadores de secuencia
➢ Detectores de código
Detectores de código
El detector de código nos sirve para comparar una secuencia con el código que se ha
dispuesto para que se active una salida en dependencia de cómo se haga el diseño
Ilustración 15 Detector de Código
Comportamiento:
Continuo
También denominado como detector de secuencia con superposición, es un detector de
secuencia que permite la superposición, los bits finales de una secuencia pueden ser el
comienzo de otra secuencia, para ello se toma en consideración todos los datos de la
secuencia presentada para ser analizada de manera continua es decir tomando bit a bit tras
cada salida formando un código para analizar, es decir en caso de tener un código de 2 bits se
debe analizar de la secuencia 2 bits tomando el bit final como inicio de la siguiente
agrupación a analizar siempre que se forme la combinación correcta [1]
Ilustración 16 Detector continuo de cadena 10
Ejemplo. – Código: 10
Secuencia: 010111011011
Ilustración 17 Detector continuo (Ejemplo)
Segmentado
Denominado también como detector de secuencia sin superposición, en el cual el último bit
de una secuencia no se convierte en el primer bit de la secuencia siguiente aquí se restablece
al estado de inicio cuando se ha detectado la secuencia, para generar una salida se analiza los
datos de la secuencia de manera que se los agrupa en función del número de bits del código
así solamente el ultimo bit de cada grupo genera la salida sea cero o uno en relación al
código, por lo cual los bits antecesores al final tendrán el valor de cero y solamente el bit final
determinara la salida teniendo por ejemplo un código de 10 para lo cual la secuencia será
dividida en grupos de 2 bits así el primer bit será cero y el segundo bit será el que genere el
valor de la salida en dependencia al anterior para formar la combinación correcta. [1]
Ilustración 18 Detector segmentado de cadena 10
Ejemplo. –
Código: 10
Secuencia: 010111011011
Ilustración 19 Detector Segmentado
Modelo general de un circuito secuencial
Antes de exponer una técnica de diseño de contadores específica, vamos a comenzar con una
definición general de circuito secuencial o máquina de estados: un circuito secuencial está
formado por una etapa de lógica combinacional y una sección de memoria (flip-flops), como
se muestra en la ilustración 1. En un circuito secuencial sincronizado, hay una entrada de
reloj en la etapa de memoria, tal como se indica. [1]
Ilustración 20: Circuito secuencial general sincronizado [1]
Máquinas de Mealy
En una máquina de Mealy:
• El estado siguiente depende de la entrada y del estado actual.
• La salida depende de la entrada y del estado actual. [28]
Ilustración 21: Máquinas de Mealy [28]
Máquina de Moore
En una máquina de Moore:
• El estado siguiente depende de la entrada y del estado actual.
• La salida depende de exclusivamente del estado actual.
Toda máquina de Moore es un caso particular de una máquina de Mealy. [28]
Ilustración 22: Máquina de Moore [28]
Desarrollo de un circuito secuencial
Pasos dados en el diseño de este contador. En general, estos pasos se pueden aplicar a
cualquier circuito secuencial.
1. Especificar la secuencia del contador y dibujar un diagrama de estados. [29]
2. Obtener la tabla del estado siguiente a partir del diagrama de estados.
3. Desarrollar una tabla de transiciones que muestre las entradas del flip-flop requeridas
para cada transición. La tabla de transiciones es siempre la misma para cada tipo de
flip-flop. [29]
4. Transferir los estados J y K de la tabla de transiciones al mapa de Karnaugh. Utilizar
un mapa de Karnaugh para cada entrada de cada flip-flop. [29]
5. Formar los términos productos a partir de los mapas para generar una expresión
lógica, para cada entrada de los flip-flops. [29]
6. Implementar la expresión con lógica combinacional y conectarla a los flip-flops para
crear el contador. [29]
Metodología para diseño de un detector de secuencia
1. Identificación de entradas y salidas [28]

2. Diagrama de transición de estados [28]
3. Comprobación y reducción del diagrama [28]
4. Determinación del número de biestables [28]
5. Asignación de estados [28]
6. Tablas de transición de estados, salidas y excitación del autómata [28]
7. Minimización de las funciones lógicas [28]
8. Diseño del circuito [28]
Detector de secuencia Mealy y Moore
Un detector de secuencia de Mealy realiza un análisis de todos sus estados para identificar
tanto la secuencia correcta o incorrecta, dentro de esta puede existir dos la forma continua y
segmentada estos dos tipos de soluciones se diferencia por los estados que va a desarrollos ya
que en la segmentada tiene más estados que la continua. [28]
Definición y estructura de Arduino IDE Y PIC C COMPILER
Arduino
Según Arduino.cc Indica que: Arduino es una plataforma electrónica de código abierto
basada en hardware y software fáciles de usar. Las placas Arduino pueden leer entradas y
convertirlo en una salida, activando un motor, encendiendo un LED, publicando algo en
línea, etc. [30]
Según Proserquisa Indica que: Arduino es un micro controlador de código abierto, una
sencilla y económica placa con entradas y salidas, analógicas y digitales, en un entorno de
desarrollo en el lenguaje de programación Processing basado en Java con una fácil curva de
aprendizaje. [31]
Según Grupo Halley de la Universidad Industrial de Santander Indica que: Arduino

es una plataforma de código libre diseñada para facilitar proyectos de electrónica. Posee un
entorno grafico de desarrollo que usa un lenguaje de programación processing/wiring y un
gestor de arranque; en lo que respecta al hardware está compuesta por un microcontrolador y
puertos de entrada y salida. [32]
Arduino es una plataforma para desarrollo de proyectos de microcontroladores en la cual

tenemos el Hardware (placas, módulos y shields), Software de programación libre con una
adaptación del lenguaje C y soporte mediante la página oficial del mismo nos permite
actualizar las herramientas para proyectos electrónico.
PIC C COMPILER
Según Servicios informáticos personalizados, Inc. Indica que: Pic C Compiler

proporciona a los desarrolladores integrado con un conjunto de herramientas y un código
inteligente optimización de Microchip PIC, permitiendo definir configurar y administrar
interrupciones fácilmente. [33]
Según Pic C Compiler indica que: PIC C Compiler es un inteligente y muy optimizado
compilador C que contienen operadores estándar del lenguaje C y funciones incorporados en
bibliotecas que son específicas a los registros de PIC, proporcionando a los desarrolladores
una herramienta poderosa para el acceso al hardware las funciones del dispositivo desde el
nivel de lenguaje C. [34]
Según Eduardo García Breijo. Indica que: El compilador C de CCS ha sido

desarrollado específicamente PIC MCU, obteniendo la máxima optimización del compilador
con estos dispositivos. Dispone de amplias librerías, siendo un compilador que convierte el
lenguaje de alto nivel a instrucciones en código máquina. [35]
PIC C Compiler es una plataforma que permite desarrollar código de programación

similar al de C, el mismo que permite controlar microcontroladores y manipularlos desde otro
dispositivo estableciendo una conexión por medio de un archivo ejecutable.
Características de Arduino IDE Y PIC C COMPILER
ARDUINO IDE
Plataforma de desarrollo de proyectos de Microelectrónica.
Arduino ofrece Hardware ofrece Placa, Módulos y Shields.
En software permite programar los parámetros de hardware. [35]
PIC C COMPILER
Permite programar microcontroladores Pic.

IDE de programación de microcontroladores en hexadecimal.
El compilador contiene funciones integradas que permiten acceder al hardware Pic.
No es un software libre.
Es integrable con Matlab.
La entrada y Salida discreta son manejadas.
Facilidad de comprensión analítica, de escritura y comprensión.
Amplia gama de librerías predeterminadas del programa. [35]
ARDUINO IDE
Ilustración 23 Proceso de Creación de Archivos
Ilustración 24 Microcontroladores
Ilustración 25 Diferencias entre ARDUINO y Pic c compiler
Ilustración 26 Partes de Arduino IDE
INTERFAZ DE HARDWARE
Productos Arduino
Explore la gama completa de productos oficiales de Arduino, que incluyen placas,
módulos (un factor de forma más pequeño de las placas clásicas), shields (elementos que se
pueden conectar a una placa para darle características adicionales) y kits. [36]
Placas
Arduino es un proyecto y no un modelo concreto de placa, lo que quiere decir que
compartiendo su diseño básico se puede encontrar con diferentes tipos de placas. En la
actualidad existen varias formas, tamaños y colores para las necesidades del proyecto en el
que se esté trabajando, las hay sencillas o con características mejoradas, Arduino orientados
al Internet de las Cosas o la impresión 3D y, por supuesto, dependiendo de estas
características por lo tanto el costo variara. A continuación, se mostrará en las ilustraciones
5,6,7,8 los diferentes tipos de Arduinos básicos, internet de las cosas, para educación y
retirado que existen a la venta en la página oficial de Arduino. [36]
Ilustración 27 Placas de Arduino Basicos [36]
Ilustración 28 Placas de Arduino lot [36]
Ilustración 29 Placa Arduino Educativo [36]
Ilustración 30 Placa Arduino Retirado [36]
INTERFAZ DE SOFTWARE
Para programar la placa es necesario descargarse de la página web de Arduino el entorno de

desarrollo (IDE). En la ilustración 9 se muestra el aspecto del entorno de programación. [36]
Ilustración 31 Interfaz de Software de Arduino [36]
ESTRUCTURA DE UN PROGRAMA EN ARDUINO IDE

La estructura básica del lenguaje de programación de Arduino es bastante simple y se
compone de al menos dos partes. Estas dos partes necesarias, o funciones, encierran bloques
que contienen declaraciones, estamentos o instrucciones como se visualiza en la Ilustración
10.
Ilustración 32 Código Arduino [36]
En donde setup() es la parte encargada de recoger la configuración y loop() es la que

contienen el programa que se ejecutará cíclicamente (de ahí el termino loop –bucle-). Ambas
funciones son necesarias para que el programa trabaje. [36]
PIC C COMPILER
PIC C Compiler es un IDE Completo, siendo una interfaz de programación y compilación, ya

que este no contiene una interfaz de transferencia.
Ilustración 33 Interfaz de Pic c compiler
Ilustración 34 Estructura de un Programa en Pic C Compiler
Proceso de compilación ayuda a generar el archivo de acuerdo con la necesidad que se le

utilizará.
Ilustración 35 COMPILACIÓN DEL Archivo en Pic c Compiler [35]
Al desarrollar un programa se crea un archivo c. cómo se visualiza en la siguiente figura.
Ilustración 36 Archivo .c del código de PIC [35]
Mientras se compila el programa que se está utilizando se guarda como archivo. .hex
Ilustración 37 Archivo .hex en la carpeta de PIC [35]
El archivo .hex es conjunto de códigos binarios escrito en hexadecimal que establece la

dirección y código.
Ilustración 38 Código binario dentro del Ejecutable [35]
Al compilar el programa se generan varios archivos como se visualiza en la siguiente figura:
Ilustración 39 Archivos generado al compilar el programa en PIC [35]
Al tener ya el archivo hexadecimal es importante tener la trasferencia de hardware y software

conocido como pickit para poder llevar la información al microcontrolador como se visualiza
en la figura. [35]
Dentro de la interfaz de software del Pic c compiler no tiene case sensitive por el contrario
del Arduino IDE que si es sensible al reconocimiento de mayúsculas o minúsculas .
Librerias de PIC C COMPILER

LIBRERIAS INCORPORADAS
o #USE FAST_IO (puerto)

Esta directiva afecta al código que el compilador generara para las instrucciones de entrada y
salida. Este método rápido de hacer I/O ocasiona que el compilador realice I/O sin programar
el registro de dirección. El puerto puede ser A-G [37]
Ejemplo: #use fast_io(A)
FUNCIONES DE I/O DISCRETA

• SET_TRIS_A(value)
• SET_TRIS_B(value)
• SET_TRIS_C(value)
• SET_TRIS_D(value)
• SET_TRIS_E(value)
Estas funciones permiten escribir directamente los registros tri-estado para la
configuración de los puertos.
Esto debe usarse con FAST_IO() y cuando se accede a los puertos de I/O como si fueran
memoria, igual que cuando se utiliza una directiva #BYTE. Cada bit de value representa una
patilla. Un ´1´ indica que la patilla es de entrada y un ´0´ que es de salida.
Ejemplo: SET_TRIS_B(0x0F); //pone B0, B1, B2 y B3 como estradas; B4, B5, B6 y B7
como salidas. [37]
Pantalla LCD con Lenguaje C
El compilador CCS incorpora un fichero(driver) para manejar fácilmente una pantalla LCD.
El archivo es LCD.c y debe llamarse con un #include:#include LCD.c [37]
Teclado matricial con Lenguaje C

El compilador de C posse el driver KBD.c para manejar un teclado 3x4. Las funciones que
incorporan son las siguientes:
• kbd_init() Inicializa el sistema para manejo del teclado. Debe ser la primera función del
programa.
• kbd_getc() Devuelve el valor de la tecla pulsada en función de la tabla que tiene programada.
[37]
INTERFAZ DE HARDWARE
PICKIT O GRABADOR PIC
El grabador de PIC, quien se encarga de enviar el programa hacia la memoria interna del PIC,
es decir realiza la transferencia del programa de la PC hacia el PIC, esta herramienta tiene su
complemento que es la parte física, es decir un circuito físico sin el cual no sirve de nada. El
grabador es una tarjeta electrónica, que posee entre otros elementos un zócalo para insertar en
PIC, un puerto de comunicaciones, que puede ser serial, USB, en algunos casos paralelo. [38]
Existen diferentes modelos de grabadores, desde el punto de vista del puerto pueden ser
serial o paralelo, desde el punto de vista de la alimentación eléctrica, pueden ser con
alimentación o sin alimentación, pueden ser universales o no universales, los grabadores
actuales son universales, usan el puerto USB y no requieren alimentación externa adicional,
es decir toman energía del mismo puerto USB de la PC, en la siguiente figura se observa un
grabador de PIC universal, que utiliza como parte de su circuito a otro PIC que normalmente
es el 18F2550. [38]
Ilustración 40 Grabador de PIC universal sin Alimentación interna que Logra la Comunicación Serial [38]
INTERFAZ DE SOFTWARE
El compilador CCS C facilita el proceso de construcción y diseño, permitiendo la creación de

programas mediante una gran variedad de herramientas por medio del lenguaje C. El
compilador posee un entorno de trabajo ideal, intuitivo y fácil de manejar.
Dentro de la interfaz del software de Pic como se visualiza en la Ilustración12, se puede
encontrar la Estructura que se detalla en la Ilustración 14 y 15. [39]
Ilustración 41 Ejemplo de Programación en PIC C Compiler [39]
Ilustración 42 Partes de la Programación [39]

Para confirmar que una estructura de un Programa dentro Pic C Compiler es correctamente
desarrollado se debe tener en cuenta:
DIRECTIVAS DE PROCESADO: Controlan la conversión del programa o código máquina

por parte del compilador. [35]
PROGRAMAS O FUNCIONES: conjunto de instrucciones. Puede haber uno o varios; en

cualquier caso siempre debe haber uno definido como principal mediante la inclusión de la
llamada main(). [35]
INSTRUCCIONES: Indican como debe comportar el PIC en todo momento.

COMENTARIOS: Permiten describir lo que significa cada línea del programa. [35]
Simulación de ARDUINO IDE Y PROTEUS
Para la simulación de Arduino y de Pic C Compiler necesitamos cargar las librerías de

Arduino e instalarlas dentro de las librerías, y de la misma manera procedemos con Pic C
Compiler, son casi similares, con la diferencia que en Pic cuando un archivo se guarda, este
crea una carpeta en la que se guardan todos los archivo incluido el archivo ejecutable (.hex),
en cambio, para Arduino debemos generar el archivo ejecutable al compilarlo y dentro del
direccionarlo hacia una carpeta o también copiar su link de ubicación para poder copiarlo en
Proteus y poder ejecutar cualquier proceso practico.
Entonces se muestran los pasos a desarrollar dentro de ARDUINO para poder ejecutar un
código y controlarlo en Proteus. [40]
ARDUINO
Ya instaladas las librerías se procede a seleccionar a placa de Arduino que se desee utilizar.
Ilustración 43 Instalación de las Librerías de Arduino en Proteus [40]
A continuación, se debe generar el archivo ejecutable en Arduino de dos maneras, la primera

desde el menú asignando una dirección al archivo o solamente copiando su dirección, como
las ilustraciones siguientes. [40]
PROCESO DE LA GENERACION DEL ARCHIVO EJECUTABLE
Ilustración 44 Proceso para Generar el Archivo hex de Arduino [40]

SIMULACION DE PIC C OMPILER Y PROTEUS
PIC C OMPILER
De la misma manera con el archivo ejecutable de PiC C Compiler debemos ubicar su

dirección y lo copiamos y pegamos en el archivo ejecutable de Proteus.
PROCESO DE LA GENERACION DEL ARCHIVO EJECUTABLE
Ilustración 45 Proceso de Creación del Archivo HEX en PIC C Compiler [35]
Librerías, Fusibles e Interrupciones
Librerías
Las librerías son archivos compilados que ayudan a los programas para que obtengan más
funciones. Estas funciones controlan el hardware y agrega funciones de procesamiento al
software.
Ilustración 46: Librerías

Fusibles (PIC C Compiler)
Los fusibles son bits de configuración de funcionamiento, los cuales pueden habilitar o
deshabilitar servicios.
Como ejemplos de fusibles tenemos a: Master Clear, Watchdog, Low Voltage Programing,
CP, MP, etc.
Ilustración 47:Fusibles
Interrupciones
Es una función asociada a un evento o programa. Este se ejecuta cuando el evento se genera.
Ilustración 48: Interrupciones
Pic C Compiler
PIC C Compiler es un inteligente y muy optimizado compilador C que contienen operadores

estándar del lenguaje C y funciones incorporados en bibliotecas que son específicas a los
registros de PIC, proporcionando a los desarrolladores una herramienta poderosa para el
acceso al hardware las funciones del dispositivo desde el nivel de lenguaje C [1].
El compilador CCS contiene más de 307 funciones integradas que simplifiquen el acceso al
hardware, mientras que la producción eficiente y altamente optimizado código. Se incluyen
funciones de hardware del dispositivo de características tales como [1]:
* Temporizadores y módulos PWM

* Convertidores A / D
* de datos on-chip EEPROM
* LCD controladores
* Memoria externa buses
* Entre otras...
PIC Wizard
Un PIC Wizard es un asistente el cual te permite configurar de manera rápida algunos

elementos, entre ellos la barra de herramientas dentro de PIC Wizard
Ilustración 49: PIC WIZARD
Las opciones de PIC Wizard son las siguientes:

General
Nos permite observar diferentes configuraciones que están insertadas en el archivo .h
(header), este archivo solo se genera cuando nosotros utilizamos el PIC Wizard caso contrario
solo se genera el archivo. hex:
Ilustración 50: General
Communications
Se observa la ventana con el código donde se va creando directamente los métodos o
directivas de configuración.
Ilustración 51:Comunicación-Código
Igualmente se tiene la página de opciones de comunicación en donde podemos ir
configurando de acuerdo con lo que deseemos:
Ilustración 52:Comunicación-Opciones
SPI and LCD

Con la siguiente opción se puede elegir si deseamos trabajar con SPI, con LCD o con ambas.
Ilustración 53:SPI-LCD
Times
En la ventana Times podemos observar las siguientes opciones, donde se puede configurar el
tiempo.
Ilustración 54:Times
Analog
Venta de opciones:
Ilustración 55:Analog-Opciones
Ventana de código:
Ilustración 56:Analog-Código
Drivers (Librerías de Hardware)
Si nos dirigimos a la ventana de drivers podemos elegir con que elemento deseamos
trabajar, como ejemplo una pantalla LCD o un teclado matricial.
Ilustración 57:Drivers
Header Files (Librerías de Software)
Esta opción nos permite elegir librerías para software, la cual nos habilita más funciones:
Ilustración 58:Header Files
Por ejemplo, librerías float (datos flotantes), math (funciones matemáticas), stdio (realizar
capturas de texto o impresiones de texto en pantallas de manera más fácil).
LCD Options
En la ventana de LCD se elige el modelo a gusto del programador.
Ilustración 59:LCD Options
Interrupciones
La ventana de opciones de interrupciones nos permite escoger el tipo que deseemos.
Ilustración 60:Interrupciones-Opciones
Nos lanza el siguiente código, que esta insertado en el archivo .c antes del main, se declara la
librería y el método, también nos aparece el permiso para usar interrupciones ENABLE:
Ilustración 61: Interrupciones-Código
4. Control DIO, AIO, Sensores y Actuadores

Control DIO
DIO (Digital Input – output) (Entradas y salidas digitales)
Una señal digital es una señal que existe en uno de dos estados: alta o baja, abierta o cerrada,
encendida o apagada. Un dispositivo de entrada y salida digital (DIO) es un hardware que
envía o recibe estas señales digitales. Los dispositivos DIO generalmente se construyen
alrededor de relés simples como los relés de láminas. Estos relés normalmente están abiertos,
pero se cierran cuando se les envía energía. Cuando el relé se cierra, envía una señal que
comunica un mensaje o activa otro dispositivo. Los dispositivos DIO pueden ser solo de
entrada, proporcionando entrada de sensores; solo salida, envío de señales para activar un
dispositivo; o bidireccional, proporcionando señales de entrada y salida [1].
DIO básicamente es un control totalmente digita, es decir tiene parámetros de entrada

digitales, parámetros de salidas digitales como, por ejemplo: un switch, los pulsadores, el uso
de teclados matriciales, el uso de sensores, etc. En otras palabras un control dio es cualquier
cosa o cualquier aparato que nos brinde información solamente de 0 y 1.
Entrada digital: una entrada digital detecta si un voltaje está por encima o por debajo de un
umbral específico. Si el voltaje es mayor que algún valor, la computadora detectará la entrada
digital como alta y establecida en 1. Si el voltaje es menor que algún valor, la computadora
detectará la entrada digital como baja y limpia en 0 [4].
Salida digital: una salida digital le permite controlar un voltaje con una computadora. Si la
computadora indica que la salida sea alta, la salida producirá un voltaje (generalmente
alrededor de 5 o 3.3 voltios). Si la computadora indica que la salida sea baja, está conectada a
tierra y no produce voltaje [4].
Control AIO
AIO (Analog Input - Output)
Un dispositivo AIO es un hardware que envía o recibe señales de entrada y salida análoga,
básicamente es el complemento del control DIO ya que estos trabajan conjuntamente.
Entradas analógicas: una señal eléctrica analógica es aquella en la que los valores de la
tensión o voltaje varían constantemente y pueden tomar cualquier valor. En el caso de la
corriente alterna, la señal analógica incrementa su valor con signo eléctrico positivo (+)
durante medio ciclo y disminuye a continuación con signo eléctrico negativo (–) en el medio
ciclo siguiente [5].
Salida análoga: en realidad los microcontroladores no pueden generar salidas análogas, pero
pueden simularla por medio de una técnica conocida como PWM: Modulación por Ancho de
Pulso (en inglés Pulse-Width Modulation) [6].
Esta técnica consiste en hacer fluctuar rápidamente el estado de un pin digital, cambiando su
nivel de LOW a HIGH, o sea de 0v a 5v a alta velocidad y controlando el tiempo que
permanece encendido o apagado. Este tiempo es conocido como ciclo de trabajo o “duty
cycle”. Por ejemplo, un ciclo de trabajo de 100% corresponde con una salida constante de 5v,
mientras que un ciclo de trabajo de 50% corresponde con una salida de 2.5v [6].
Ilustración 1.-Modulación de Ancho de pulso [1].
La modulación por ancho de pulso permite, por ejemplo, cambiar la luminosidad de un LED
de manera gradual o controlar la velocidad de un motor de corriente continua. Arduino cuenta
con la función analogWrite () que permite generar modulación por ancho de pulso en los
pines digitales 9, 10 y 11 en las placas que usan el Atmega8 y en los pines 3, 5 ,6, 9, 10 y 11
en las nuevas placas que usan Atmega168/328 [6].
Sensores y actuadores
Sensor
Un sensor es un dispositivo capaz de detectar magnitudes físicas o químicas, llamadas
variables de instrumentación, y transformarlas en variables eléctricas. Las variables de
instrumentación pueden ser, por ejemplo: temperatura, intensidad lumínica, distancia,
aceleración, inclinación, desplazamiento, presión, fuerza, torsión, humedad, movimiento, pH,
etc. Una magnitud eléctrica puede ser una resistencia eléctrica (como en una RTD), una
capacidad eléctrica (como en un sensor de humedad o un sensor capacitivo), una tensión
eléctrica (como en un termopar), una corriente eléctrica (como en un fototransistor), etc [2].
Los sensores se pueden clasificar en función de los datos de salida en:
− Digitales
− Analógicos
Y dentro de los sensores digitales, estos nos pueden dar una señal digital simple con dos
estados como una salida de contacto libre de tensión o una salida en bus digital [2].
Características de los sensores
− Rango de medida: dominio en la magnitud medida en el que puede aplicarse el sensor

[2].
− Precisión: es el error de medida máximo esperado [2].
− Offset o desviación de cero: valor de la variable de salida cuando la variable de entrada
es nula. Si el rango de medida no llega a valores nulos de la variable de entrada,
habitualmente se establece otro punto de referencia para definir el offset [2].
− Linealidad o correlación lineal.
− Sensibilidad de un sensor: suponiendo que es de entrada a salida y la variación de la
magnitud de entrada [2].
− Resolución: mínima variación de la magnitud de entrada que puede detectarse a la salida
[2].
− Rapidez de respuesta: puede ser un tiempo fijo o depender de cuánto varíe la magnitud a
medir. Depende de la capacidad del sistema para seguir las variaciones de la magnitud de
entrada [2].
− Derivas: son otras magnitudes, aparte de la medida como magnitud de entrada, que
influyen en la variable de salida. Por ejemplo, pueden ser condiciones ambientales, como
la humedad, la temperatura u otras como el envejecimiento (oxidación, desgaste, etc.) del
sensor [2].
− Repetitividad: error esperado al repetir varias veces la misma medida [2].
Actuadores
Un actuador es un dispositivo capaz de transformar energía hidráulica, neumática o eléctrica
en la activación de un proceso con la finalidad de generar un efecto sobre elemento externo.
Este recibe la orden de un regulador, controlador o en nuestro caso un Arduino y en función a
ella genera la orden para activar un elemento final de control como, por ejemplo, una válvula
[2].
Existen varios tipos de actuadores como son:
− Electrónicos
− Hidráulicos
− Neumáticos
− Eléctricos
− Motores
− Bombas
Periféricos
Periférico es la denominación genérica para designar al aparato o dispositivo auxiliar e
independiente conectado a la unidad central de procesamiento o en este caso a Arduino. Se
consideran periféricos a las unidades o dispositivos de hardware a través de los cuales
Arduino se comunica con el exterior, y también a los sistemas que almacenan o archivan la
información, sirviendo de memoria auxiliar de la memoria principal [2].
Ejemplos de periféricos:
− Pantallas LCD
− Teclados
− Memorias externas
− Cámaras
− Micrófonos
− Impresoras
− Pantalla táctil
Procesamiento de Sensores
➢ Acondicionamiento de señal
➢ Hardware o Software
Comunicaciones
La Comunicación es un proceso de intercambio de información, en el que un emisor

transmite a un receptor algo a través de un canal esperando que, posteriormente, se produzca
una respuesta de dicho receptor, en un contexto determinado [3].
La comunicación es el proceso de comunicar o compartir un mensaje y nos encontramos los

siguientes elementos:
– Emisor: es el que emite el mensaje. Ejemplos: un sujeto individual o un grupo de personas,

pero también un mecanismo que nos avisa de que algo falla o un elemento de la naturaleza
que nos alerta de que el tiempo van a cambiar [3].
– Receptor: es el que recibe el mensaje y lo interpreta. Ejemplos: un sujeto concreto o un

grupo, así como, también, puede serlo un mecanismo que actúa cuando otro le manda una
señal [3].
– Mensaje: es la información que se quiere transmitir. Ejemplos: puede encontrarse

codificado en uno de los diferentes tipos de código: puede ser un mensaje hablado, escrito,
dibujado, grabado en cd, etc.) [3].
– Canal: es el medio a través del cual se transmite el mensaje. Ejemplos: puede ser un medio
artificial, como las cartas o un cd, o uno natural, como el aire [3].
– Código: Conjunto de signos y reglas que, formando un lenguaje, ayudan a codificar el

mensaje. Podemos encontrar lenguajes simples, como la luz roja sobre la puerta de un estudio
de revelado, o más complejos como los distintos idiomas del mundo [3].
– Contexto: Conjunto de circunstancias (lugar, hora, estado anímico de los interlocutores,

etc.) que existen en el momento de la Comunicación. Es importante a la hora de interpretar
correctamente el mensaje [3].
Medios de Comunicación
− Medio Guiado
− Medio Inalámbrico
Medio físico o Cableado
En esta variante la información se transmite a través de un medio físico, codificando la

información en forma de señales eléctricas, a través de medios conductores de la electricidad,
como los cables de cobre. La comunicación alámbrica sirve de canal en distancias pequeñas,
como en el tramo entre una antena y el televisor, o entre distintos ordenadores [7].
Por ejemplo, en los hogares nos podemos conectar a otros equipos mediante un módem, que
transforma los unos y ceros que usa el ordenador en sonidos para enviarlos por la línea de
teléfono. En los casos más modernos la conexión a Internet se realiza mediante el sistema de
banda ancha (ADSL o RDSI), mediante el cual se transmite por la misma línea sonidos y
datos a frecuencias distintas, es decir, como si se enviasen en diferente color [7].
Ejemplos de comunicaciones Cableada
− Comunicación ETH
− Comunicación Serial
− Comunicación I2C
− Comunicación SPI
Medio Inalámbrico
La comunicación inalámbrica suele ser más adecuada y barata. En esta variante, la

comunicación se lleva a cabo a través del aire, por medio de ondas electromagnéticas [7].
Una onda consiste en una perturbación que se propaga a través del espacio. Por ejemplo, una
membrana que vibra transmite su movimiento de vaivén al aire, y éste transmite esa vibración
mediante contracciones y expansiones en las moléculas. Esto constituye el sonido, y este tipo
de ondas se denominan ondas mecánicas, pues necesitan un medio material (aire, agua, metal,
...) para poder propagarse [7].
Ejemplos de comunicaciones Inalámbrica:
− Comunicación RF
− Comunicación WIFI
− Comunicación Bluetooth
− Comunicación Zigbee
5. Comunicaciones
La comunicación es un proceso que consiste en la transmisión e intercambio de mensajes

entre un emisor y un receptor, dicho de otra forma, la comunicación es la acción consciente
de intercambiar información entre dos o más participantes con el fin de transmitir o recibir
información u opiniones distintas. En este proceso participan varios elementos:
• Emisor: es quien transmite el mensaje

• Receptor: es el que recibe el mensaje.
• Código: es el conjunto de signos que serán utilizados para crear el
• Mensaje: es la información o conjunto de datos que se transmiten.
• Canal de comunicación: es el medio físico que se utilizará para enviar el mensaje
• Ruido: son todas las distorsiones que pueden influir en la recepción del mensaje original,
y pueden ser tanto del emisor, como del canal o del receptor.
• Retroalimentación o feedback: en una primera instancia, es la respuesta del receptor hacia
el mensaje recibido.
• Contexto: son las circunstancias en las que se desarrolla el proceso de comunicación.
Tienen influencia directa en la interpretación del [41]
Comunicación Serial
Un puerto Serial es un módulo de comunicación digital para un sistema embebido. Es decir,
permite la comunicación entre dos dispositivos digitales. Cuenta con dos conexiones, RX y
TX. Lo que nos indica los modos de comunicación que puede manejar, Full-dúplex, Dúplex y
Simplex [13]
Ilustración 62: Tipo de comunicación serial [42]
Cada dato se transmite bit a bit, un bit a la vez, por lo tanto, se hace mucho más lenta, pero
tiene la ventaja de necesitar menos líneas y las distancias a las cuales se puede transferir la
información son mayores
Comunicación Serial Sincrónica
Se requiere adicionar una línea que contenga pulsos de reloj que indiquen que el dato que
viaja en la otra línea de datos es válido; la duración del bit está determinada por la duración
del pulso de sincronismo. [43]
Comunicación Serie Asincrónica
En esta comunicación los pulsos de reloj no son necesarios y se utilizan otros mecanismos
para realizar la transferencia de datos. [43]
Comunicación UART con PIC
La comunicación UART o comunicación serial sólo utiliza tres líneas

• Una para recibir los datos Rx
• Otra para trasmitir los datos Tx
• la línea común GND.
Ilustración 63: Pines para la Comunicación Serial con PIC [43]
El pic 16F887 solo tiene un puerto UART físico, es por eso que solo tiene un solo RX y un
solo TX para realizar la comunicación serial. Si necesitamos adicionar más puertos de
comunicación serial con pic, podremos hacerlo con ayuda del PIC C Compiler creando
UARTS VIRTUALES
Comunicación I2C
Este tipo de comunicación puede ser de gran ayuda cuando se van a utilizar varios
microcontroladores para almacenar un registro de datos hacia una sola memoria o cuando se
va a mostrar información en una sola pantalla. [44]
Ilustración 6: Comunicación I2C. [44]
¿Cómo trabaja la comunicación I2C?
Para poder reconocer cada uno de los dispositivos conectados a los DOS hilos del bus I2C, a
cada dispositivo se le asigna una dirección. Así en este tipo de comunicaciones el MAESTRO
es el que tiene la iniciativa en la transferencia y este es quien decide con quien se quiere
conectar para enviar y recibir datos y también decide cuando finalizar la comunicación. Los
DOS hilos del BUS interfaz de comunicación I2C PIC son líneas de colector abierto donde
una de las líneas lleva la señal de reloj y es conocida como (SCL), y la otra línea lleva los
datos y es conocida como (SDA). [44]
La conexión I2C entre un maestro y varios esclavos se muestra a continuación:
Ilustración 7: I2C entre un maestro y varios esclavos [44]

El número de dispositivos que pueden conectarse de esta forma y además la longitud del BUS
es limitada por la capacidad de direccionamiento (de 7 a 10 bits) y por la máxima carga del
BUS (400pF). A diferencia de SPI, el protocolo I2C sólo necesita dos conexiones comunes
con todos los dispositivos esclavos. Una línea llamada SCL para el reloj (recordemos que el
protocolo I2C es síncrono) y otra línea llamada SDA para los datos.
Ilustración 8: Conexión I2C. [44]
Para evitar la contención del bus, los dispositivos pueden forzar la línea a nivel bajo, pero
nunca a nivel alto. Se evita así que un dispositivo trate de forzar el bus a nivel alto mientras
que otro trata de ponerlo a nivel bajo
Diagrama de conexión del bus I2C entre placas Arduino

Con el protocolo I2C, también es posible comunicarse entre diferentes sistemas (sensores,
pantalla LCD, Raspberry Pi, etc.). Un ejemplo interesante es la comunicación entre varias
placas Arduino. Para esto, necesitamos escribir al menos dos programas, uno para la tarjeta
Ilustración 9: conexión del bus I2C entre placas Arduino. [44]
Funcionamiento de la Comunicación I2C PIC

La transmisión de datos se inicia con un bit de inicio (START) y termina con un bit de
finalización (STOP). El bit de START se reconoce porque la línea SDA pasa de un estado
lógico alto para un estado lógico de bajo cuando la línea SCL está en nivel alto. El STOP se
establece cuando hay una transición de bajo a alto en la línea SDA, cuando SCL está en un
nivel alto. [45]
Ilustración 10: Funcionamiento de la Comunicación I2C. [46]
Cuando comienza la transmisión de datos, el MAESTRO envía la dirección del ESCLAVO

con el cual se quiere comunicar, esta dirección puede ser de 7 o 10 bits con formato de byte
(uno o dos bits respectivamente) Después de la dirección se adiciona 1 bit, que indica si se
desea ESCRIBIR o LEER (R/W). [46]
Ilustración 11: Comunicación SPI. [46]
El bus spi en Arduino
Para usar el puerto SPI en Arduino el IDE Standard proporciona la librería "SPI.h" que
contiene las funciones necesarias para controlar el hardware integrado de SPI.Asimismo, el
entorno de programación de Arduino define las constantes SCK, MOSI, MISO, y SSpara los
pines de SPI. Usar estos "alias" en nuestro código hace que sea más fácil de intercambiar
programas entre modelos placas.
Las funciones básicas para hacer funcionar el bus SPI son las siguientes:
1 SPI.begin(); // Inicia el bus SPI
2 SPI.transfer(c); // Envía un byte
3 SPI.attachInterrupt(); // Activar la interrupción para recibir datos
También se dispone de otras funciones para configurar las opciones del bus SPI.
Funcionamiento de la comunicación SPI

Como vimos en el esquema anterior, una comunicación SPI básica entre dos dispositivos
tendrá 4 Lineas o en su defecto 3 lineas si uno de los dispositovos no necesita enviar nada.
Ilustración 12: Funcionamiento de la comunicación SPI. [46]
Vemos que el MASTER colocará en bajo el pin SS del Slave con el que se quiere comunicar.
Seguidamente, el master genera una señal de reloj para sincronizar el envío y recepción de
datos.
Funciones de CCS para SPI
setup_spi (modo), setup_spi2 (modo): configura el SPI de hardware en el modo especificado.
El modo configura si es maestro o esclavo, la velocidad del reloj y la configuración cambios
de reloj
spi_data_is_in (), spi_data_is_in2 () – Devuelve TRUE si el búfer de recepción SPI tiene un
byte de datos.
spi_write (valor), spi_write2 (valor): transmite el valor a través de la interfaz SPI. Esto hará
que los datos se vacíen en el pin SDO spi_read (valor), spi_read2 (valor): realiza una
transacción SPI, donde el valor se registra en el pin SDO y se devuelven los datos
sincronizados en el pin SDI.
Radiofrecuencia RF
Para este tipo de comunicación solo basta con conectar el módulo RF al Pin RX o TX del
Arduino dependiendo si es transmisor y receptor. Para este ejemplo usaremos un Arduino el
cual transmitirá seriamente información a través del RF transmisor, el módulo receptor está
conectado a un conversor USB serial (Puedes usar otro Arduino en lugar del conversor) y
visualizaremos los datos des de la pc. [47]
Ilustración 13: Conexiones entre el módulo RF y Arduino. [11]
Comunicación inalámbrica RF entre Arduino usando librerías
Una de las librería más comunes y eficientes es la VirtualWire desarrollado por Mike
McCauley, con esta librería vamos a trabajar los próximos ejemplos del tutorial
Necesitamos descargar la librera VirtualWire e importarla a nuestro IDE Arduino.
A continuación, explicamos las funciones principales de la librería:
• void vw_setup(uint16_t speed)
Inicializar el software VirtualWire, como parámetro hay que indicarle la velocidad de
operación, que representa los bits por segundo para la transmisión RF
• void vw_set_tx_pin(uint8_t pin)
Estable el pin IO digital por donde se va a transmitir los datos
• void vw_set_rx_pin(uint8_t pin)
Estable el pin digital IO por donde se va a recibir datos.
• void vw_rx_start()
Empieza a escuchar los datos provenientes por el pin_rx, es necesario llamar a esta
función para poder recibir los datos
Comunicación por RF entre microcontroladores PIC
un módulo de Radio Frecuencia (RF) modelo nRF24L01 de modo que permita establecer una
comunicación RF efectiva y fiable entre microcontroladores PIC18F. Concretamente, se
destina este proyecto al desarrollo de asignaturas sobre el uso y programación de
microcontroladores.
Bluetooth
Bluetooth es una especificación industrial para Redes Inalámbricas de Área
Personal (WPAN) que posibilita la transmisión de voz y datos entre diferentes dispositivos
mediante un enlace por radiofrecuencia en la banda ISM de los 2.4 GHz. Los principales
objetivos que se pretenden conseguir con esta norma son:
• Facilitar las comunicaciones entre equipos móviles.
• Eliminar los cables y conectores entre estos.
• Ofrecer la posibilidad de crear pequeñas redes inalámbricas y facilitar la sincronización
de datos entre equipos personales. [48]
Programación inalámbrica de Arduino por Bluetooth
Ilustración 14: Comunicación de Arduino por Bluetooth [48]
Antes de que el HC-05 funcione como un programador, debemos configurar el módulo para
que se comporte como lo esperamos. Debemos asegurarnos que el módulo tenga los
siguientes parámetros ajustados: En el caso de Arduino UNO con Optiboot: UART
configurada a 115200 baudios, 8 bits, 1 bit de parada, sin paridad
En el caso de Arduino Duemilanove / Decimilia: UART configurada a 56700 baudios, 8 bits,
1 bit de parada, sin paridad La Programación inalámbrica de Arduino por Bluetooth es una
buena alternativa cuando no tenemos a la mano la tarjeta para conectarla al puerto USB de la
computadora. Podemos convertir cualquier arduino en una placa inalámbrica, capaz de ser
programada a distancia mediante bluetooth. Incluso podemos utilizar solamente el
ATMEGA328 con el módulo bluetooth dentro de algún desarrollo. [49]
Comunicación por bluetooth entre microcontroladores PIC
Ilustración 15: Bluetooth entre microcontroladores PIC [48]
Los módulos de bluetooth HC-05 y HC-06 son módulos muy populares para aplicaciones
con microcontroladores. Se trata de dispositivos relativamente económicos y que
habitualmente se venden en un formato que permite insertarlos en un protoboard y cablearlo
directamente a cualquier microcontrolador, incluso sin realizar soldaduras. Para establecer
una conexión bluetooth es necesario utilizar los comandos HCI. [50]
Los comandos HCI permiten controlar las conexiones entre capas de enlace y otros
dispositivos bluetooth.
ZIGBEE
Es un conjunto de protocolos de alto nivel de comunicación, se utiliza para la radiodifusión
digital de datos. Esta basa en una tecnología basada en el estándar de la IEEE, el IEEE
802.15.4 , utiliza la banda ISM . [51]
Características
• Su bajo consumo.
• Su topología de red en malla.
• Su fácil integración (se pueden fabricar nodos con muy poca electrónica) [51]
Protocolos de ZigBee
Ilustración 16:Protocolos de ZigBee [51]
Unos protocolos ayudan al nodo para empezar a transmitir y que luego vuelve aquedar en
reposo para ahorrar energía. El estándar seguido por los dispositivos ZigBee es el WPAN con
una transmisión basada en la norma IEEE 802.15.4-2003. [51]
Zigbee Soporta tres tipos de topologías de red:
Estrella: presenta larga vida útil como consecuencia del bajo consumo que requiere.
Malla: en la cual existen múltiples rutas para alcanzar un destino, obteniéndose alta
confiabilidad.
Árbol: es una topología del tipo Mesh-Star que encierra los beneficios de ambas. [10]
XBee
XBee es el nombre comercial del Digi de una familia de módulos de comunicación por radio
y están basados en el estándar zigbee [10]
Ilustración 17:XBEE [51]
Los módulos XBee funcionan a 3.3V y los pines no son tolerantes a 5V.
Desde Arduino podemos alimentar un módulo XBee, pero la comunicación serie en Arduino
es a 5V y en el módulo XBee es a 3.3V. [51]
Ilustración 18:XBEE conexión en Arduino [10]
Proteus
Ilustración 19:XBEE proteus [51]
• Primero instalamos la librería de XBee

• Conectamos a un terminal virtual (Rx-Rx y Tx – Tx)
• Subimos. hex a Arduino
• Simulamos el programa.
¿QUÉ ES UNA COMUNICACION INALAMBRICA WIFI?
Es una comunicación inalámbrica mediante ondas más utilizada hoy en día. WIFI, también
llamada WLAN (wireless lan, red inalámbrica) o estándar IEEE 802.11. WIFI no es una
abreviatura de Wireless Fidelity, simplemente es un nombre comercial.
El WiFi es un mecanismo que permite, de forma inalámbrica, el acceso a Internet de distintos
dispositivos al conectarse a una red determinada. Esta tecnología, al tiempo que ofrece la
entrada a la gran red de redes, vincula diferentes equipos entre sí sin la necesidad de cables
[4].
Dicha conexión inalámbrica es posible gracias al uso de radiofrecuencias e infrarrojos,
empleados para la transmisión de información. Este hecho se traduce, irremediablemente, en
una limitación, ya que el usuario deberá encontrarse dentro de un alcance específico de
cobertura para poder disfrutar de la señal. Generalmente, ese radio varía entre los 5 y los 150
metros de distancia con respecto al aparato emisor de dicha señal [4].
Pese a ser ésta su definición técnica, WiFi hace referencia, realmente, a una marca comercial
impulsada por la WiFi Alliance, cuya finalidad fue crear un mecanismo de conexión
inalámbrica que fuera compatible para diversos dispositivos. De esta forma, nació el estándar
802.11, el más empleado para vincular equipos a distancia sin cables [4].
ALCANCE DE LAS REDES WI-FI
• El alcance de las redes Wi-Fi es limitado.
• Un punto de acceso usando 802.11b puede llegar hasta los 100 metros (exterior).
• Usando 802.11n se puede llegar hasta los 200 metros.
• El alcance puede extenderse hasta algunos kilómetros, usando antenas direccionales.
• Las redes que usan la banda de 5 GHz (802.11ac) poseen un menor alcance, aunque
menos interferencia [6].
PROTOCOLOS Y ESTANDARES DE WIFI
Ilustración 1 Estándares y Protocolos Wifi [6]
DISPOSITIVOS DE DISTRIBUCIÓN O DE RED EN WIFI
Los puntos de acceso: son dispositivos que generan un set de servicio, que podría definirse
como una red wifi a la que se pueden conectar otros dispositivos. Los puntos de acceso
permiten, en resumen, conectar dispositivos de forma inalámbrica a una red existente. Pueden
agregarse más puntos de acceso a una red para generar redes de cobertura más amplia, o
conectar antenas más grandes que amplifiquen la señal [2].
Los repetidores inalámbricos: son equipos que se utilizan para extender la cobertura de una
red inalámbrica, éstos se conectan a una red existente que tiene señal más débil y crean una
señal limpia a la que se pueden conectar los equipos dentro de su alcance. Algunos de ellos
funcionan también como punto de acceso [2].
Los enrutadores inalámbricos: son dispositivos compuestos, especialmente diseñados para

redes pequeñas (hogar o pequeña oficina). Estos dispositivos incluyen, un enrutador
(encargado de interconectar redes, por ejemplo, nuestra red del hogar con Internet), un punto
de acceso (explicado más arriba) y generalmente un conmutador que permite conectar
algunos equipos vía cable (Ethernet y USB). Su tarea es tomar la conexión a Internet, y
brindar a través de ella acceso a todos los equipos que conectemos, sea por cable o en forma
inalámbrica [2].
El ancho de banda de la señal (22 MHz) es superior a la separación entre canales
consecutivos (5 MHz), por eso se hace necesaria una separación de al menos 5 canales con el
fin de evitar interferencias entre celdas adyacentes, ya que al utilizar canales con una
separación de 5 canales entre ellos (y a la vez cada uno de estos con una separación de 5 MHz
de su canal vecino) entonces se logra una separación final de 25 MHz, lo cual es mayor al
ancho de banda que utiliza cada canal del estándar 802.11, el cual es de 22 MHz.
Tradicionalmente se utilizan los canales 1, 6 y 11, aunque se ha documentado que el uso de
los canales 1, 5, 9 y 13 (en dominios europeos) no es perjudicial para el rendimiento de la red
[2].
Esta asignación de canales usualmente se hace sólo en el Punto de acceso, pues los “clientes”
automáticamente detectan el canal, salvo en los casos en que se forma una red “Ad-Hoc” o
punto a punto cuando no existe punto de acceso [2].
¿QUÉ SON LAS REDES AD HOC?
Con Wi-Fi podemos crear una conexión entre dos computadoras o entre una computadora y
un dispositivo portable, sin mediar un punto de acceso inalámbrico. Incluso de esa forma
podemos compartir una conexión de internet, funcionando uno de los equipos como un
router, AP o HotSpot. Este tipo de red virtual es llamada "red ad hoc" [3].
WIFI EN ARDUINO
A Arduino es posible añadirle conectividad Wifi de forma muy sencilla y ampliar las
posibilidades de este microcontrolador con comunicación inalámbrica Wifi.
Hay varias formas de añadir hardware Wifi a Arduino, ya sea con un shield, una breakout
board específica, con microcontroladores que tenga wifi integrado o con placas Arduinos que
tenga chip wifi en la misma placa. Veamos varios casos de estos tipos, como conectarlos y
usarlos, así como las librerías a usar en cada caso.
Buena parte del visto en Ethernet con Arduino, es válido para wifi, puesto que el protocolo
tcp/ip usado es el mismo y solo cambia el medio de comunicación. Trasladar un proyecto de
ethernet a wifi es sencillo, solo cambiando la librería para usar el hardware y adaptar los
comandos en función de los métodos que tengan las librerías.
MODULO WIFI ESP8266
Ilustración 2 Módulo ESP8266 [7]
El ESP8266 es un chip Wi-Fi de bajo coste con pila TCP/IP completa y capacidad de MCU
(Micro Controller Unit) producida por el fabricante chino Espressif Systems, con sede en
Shanghai.
El chip primero llegó a la atención de los fabricantes occidentales en agosto de 2014 con el
módulo ESP-01 [7].
Este pequeño módulo permite a los microcontroladores conectarse a una red Wi-Fi y realizar
conexiones TCP/IP sencillas utilizando comandos de tipo Hayes. Sin embargo, en ese
momento casi no había documentación en inglés sobre el chip y los comandos que aceptaba.
El precio muy bajo y el hecho de que había muy pocos componentes externos en el módulo
que sugiere que podría ser muy barato en el volumen, atrajo a muchos hackers para explorar
el módulo, el chip y el software en él [7].
El ESP8285 es un ESP8266 con 1 MB de flash incorporado, lo que permite dispositivos de un
solo chip capaces de conectarse a Wi-Fi. Muchos encapsulados del ESP8266 viene con 1 MB
de flash [7].
Ilustración 3 Módulo ESP2866 [7]
Características
• 32-bit RISC CPU

• 64 KiB de RAM de instrucciones, 96 KiB de RAM de datos
• Flash QSPI externo: 512 KiB a 4 MiB *
• IEEE 802.11 b/g/n Wi-Fi
• Interruptor TR integrado, balun, LNA, amplificador de potencia y red correspondiente
• Autenticación WEP o WPA / WPA2, o redes abiertas
• 16 GPIO pins
• SPI, I²C,
• Interfaces I²S con DMA (compartiendo pines con GPIO)
• UART en pines dedicados, más un UART de solo transmisión se puede habilitar en
GPIO2
• ADC de 1 puerto de 10 bits
• EL ESP8266 no tiene ROM y usa una ROM externa SPI y soporta hasta 16MB.
• El esp8266 es un módulo muy de moda que va alimentado a 3.3V. [7]
Otros SDK de código abierto para el ESP8266:
• NodeMCU: un firmware basado en Lua [1].

• Arduino: un firmware basado en C ++. Este núcleo permite que la CPU ESP8266 y sus
componentes Wi-Fi sean programados como cualquier otro dispositivo Arduino. El
Arduino Core ESP8266 está disponible a través de GitHub [1].
• MicroPython: una implementación de Python para dispositivos embebidos a la
plataforma ESP8266 [1].
• ESP8266 BASIC: Un intérprete básico de código abierto específicamente diseñado para
el Internet de las cosas [1].
Mongoose Firmware: Un firmware de código abierto con servicio gratuito en la nube [1].
El módulo WIFI ESP8266, que es algo muy parecido a los módulos Bluetooth y que al igual
que ellos incluyen toda la electrónica necesaria para la comunicación Radio Frecuencia en la
banda WFI, así como la pila TCP/IP y que se comunica con nosotros a través de un puerto
serie. De hecho, exactamente igual que los modos HC-06 y HC-05 se gobierna mediante
comandos AT y todo por un precio similar al de los Bluetooth [1].
Dentro de la gran cantidad de usos para este módulo caben destacar los siguientes:
• Electrodomésticos conectados.
• Automatización del hogar.
• Automatización de la industria.
• Cámaras IP.
• Redes de sensores.
• Wereables.
• IoT (Internet of Things o Internet de las Cosas)
IIoT (Industrial Internet of Things o Internet de las Cosas para el sector Industrial) [1]
La principal dificultad es la alimentación del ESP01. El ESP8266 y, en particular, el ESP01,

tiene una tensión de alimentación de 3.3V. En ningún caso puede alimentarse a una tensión
superior a 3.6V, o dañaremos el módulo.
CONECTAR ARDUINO POR WIFI CON EL MÓDULO ESP8266
Ilustración 4 Conexión con Arduino con el módulo ESP8266 [8]

Por otro lado, el consumo del módulo puede sobrepasar los 200mA, sobre todo durante la
conexión y arranques. Sin embargo, el regulador de voltaje de 3.3V de Arduino sólo puede
proporcionar 50mA (150mA en algunos modelos), lo cual es insuficiente para alimentar el
ESP01 [8].
Por tanto, necesitaremos alimentar el ESP01 con una fuente externa de 3.3V. De lo contrario
experimentaremos continuos cortes y cuelgues durante su funcionamiento, que además
pueden reducir la vida útil del ESP01 [8].
El resto de la conexión no tiene ninguna dificultad. Por un lado tenemos el pin CH_PD que
apaga o enciende el módulo conectándolo, respectivamente, a Gnd o 3.3V. Por su parte, el pin
RST reinicia el módulo si se conecta a Gnd. En algunas versiones del módulo podremos
dejarlo sin conexión pero, en general, tendremos que conectarlo a 3.3V para que el módulo
arranque [8].
Finalmente, la comunicación con el módulo se realiza mediante puerto serie. A diferencia de
la alimentación del módulo, que en ningún caso debe exceder los 3.6V, existe un amplio
debate sobre si los pines RX y TX son tolerantes a 5V (Es decir, si pueden conectarse
directamente a un sistema a un 5V) [8].
En principio, conectar RX y TX a un sistema de 5V no parece dañar la placa de forma
inmediata. De hecho, encontramos indicios en la documentación que apuntan a que podrían
ser tolerantes a 5V, sin quedar totalmente claro. No obstante, tampoco queda claro si puede
reducir la vida útil del componente [8].
SBC
Es una computadora de placa única se distingue de un kit de desarrollo tradicional o una placa
de evaluación porque constituye una plataforma completa de sistemas de computación en un
único paquete; es decir, ya tiene integrado todo el hardware y software necesario para
funcionar. [9]
Características
➢ Un procesador de aplicaciones que pueda ejecutar un sistema operativo de alto nivel,

como Linux, Android o Windows.
➢ Funcionalidad lista para usar.
➢ Conectividad inalámbrica y por cable.
➢ Un sólido ecosistema de usuarios, tarjetas de expansión y software de código abierto. [9]
Diferencia entre una SBC y MCU
➢ Un MCU, o Unidad de Microcontrolador, es una forma de sistema incorporado que

incorpora un ordenador entero en un solo chip. Bajo el capó hay un procesador, memoria,
almacenamiento y pines de entrada y salida programables.
➢ Los microcontroladores no son potentes ni fácilmente reprogramables. Pero no tienen por
qué serlo; pueden fabricarse a una escala enorme por casi nada, y pueden realizar una
serie de tareas para las que un ordenador completo no sería adecuado. [9]
LAMP SERVER
LAMP es un acónimo de «Linux, Apache, MySQL y PHP», es decir, las cuatro tecnologías
que conforman esta plataforma que corre desde el lado del servidor. Gracias a LAMP puedes
comenzar a crear sitios web, aplicaciones, realizar testing de páginas dinámicas y estáticas,
entre muchas otras cosas más. En inglés se lo conoce como LAMP stack, es decir, una
apilación de servicios y tecnologías que nos permiten una gracias a la otra, conformar la
plataforma que necesitamos. Veamos ahora qué es cada cosa y cómo funciona el servidor
LAMP. [10]
Linux: es el sistema operativo base de la plataforma, y puede ser cualquier tipo de sistema
Gnu/Linux, donde podrán ejecutarse el resto de los componentes.
Apache: se refiere al servidor Apache, que es permite alojar y despachar las páginas web
dinámicas y estáticas que son ejecutadas desde el lenguaje PHP.
MySQL: es el servidor de base de datos más popular del mundo, el cual permite alojar datos
y despacharlos desde un motor de datos centralizado.
PHP: se refiere al lenguaje de programación dinámico que revolucionó la web, y es todavía

uno de los más usados del mundo. Es al mismo tiempo el servidor PHP que permite la
ejecución de este tipo de scripts.
Desde sus inicios ha tenido una gran adopción debido a que es gratuito, funciona en cualquier
tipo de Linux, es fácil de instalar y ofrece estabilidad para montar cualquier tipo de
aplicaciones web en tiempo récord. En Windows se encuentran reemplazos de forma nativa
con el servidor WAMP, en tanto en la plataforma de Apple se le conoce comom MAMP. Una
alternativa moderna que surgió tras el nacimiento del servidor Nginx fue el stack LEMP, que
utiliza Nginx (pronunciado «enginex»), MariaDB y PHP o incluso Python/Ruby como
lenguajes de programación más modernos. Aplicaciones modernas que son 100%
compatibles con LAMP son: Wikimedia, WordPress, Joomla, PrestaShop, OpenCart,
Magento, Moodle, y casi cualquier app creada en PHP. [10]
MOSQUITTO
Mosquitto es un broker MQTT OpenSource ampliamente utilizado debido a su ligereza lo

que nos permite, fácilmente, emplearlo en gran número de ambientes, incluso si éstos son de
pocos recursos. Permite crear nuestro primer emisor y subscriptor siguiendo para ello una
jerarquía de un edificio. [11]
Ilustración 5 Mosquitto [11]
MÁQUINAS VIRTUALES
Es un contenedor de software perfectamente aislado que puede ejecutar sus propios sistemas
operativos y aplicaciones como si fuera un ordenador físico. Una máquina virtual se comporta
exactamente igual que lo hace un ordenador físico y contiene sus propios CPU, RAM, disco
duro y tarjetas de interfaz de red virtuales. Desde el punto de vista informático, una máquina
virtual es un software que crea un entorno virtual entre el sistema informático que la alberga y
el usuario final, permitiendo que se ejecute un software determinado. [12]
Ejemplos de Software para Máquinas Virtuales
• VMware
• QEMU
• Parallels
• Virtual Box
• SandBoxies
7. Modelos y Metodología de Diseño VHDL
HDL
Definiciones de HDL
Definición 1
Según Díaz Fernández Blanca un HDL es un lenguaje de programación especializado que se
utiliza para definir la estructura, diseño y operación de circuitos electrónicos y electrónicos
digitales. Así, estos lenguajes hacen posible una descripción formal de un circuito
electrónico, y posibilitan su análisis automático y su simulación. [52]
Definición 2
Según Carvajal Andre el lenguaje de descripción de hardware (HDL) es un lenguaje
informático especializado que se utiliza para programar circuitos lógicos electrónicos y
digitales. La estructura, operación y diseño de los circuitos son programables usando HDL.
HDL incluye una descripción textual que consiste en operadores, expresiones, declaraciones,
entradas y salidas. [53]
Definición 3
Según Isacar Vela son lenguajes que describen el hardware de los sistemas digitales en forma
textual. Se parecen a los lenguajes de programación, pero están orientados específicamente a
la descripción de las estructuras y el comportamiento del hardware. [54]
Definición grupal de HDL

Los HDLs son los lenguajes de programación que nos permiten describir hardware y
programar circuitos electrónicos y digitales. Estos no se ejecutan de manera secuencial como
un lenguaje de programación sino se ejecutan de manera paralela y estas llevan operadores,
declaraciones, expresiones, entradas y salidas.
Evolución de las HDLs
➢ 1960
Aparecieron los primeros lenguajes de descripción de hardware Lenguaje de descripción de
hardware. [55]
➢ 1971
El primero en el texto Computer Structures de C. Gordon Bell y Allen Newell.
Este texto introdujo el concepto de nivel de transferencia de registro, utilizado por primera
vez en el lenguaje ISP para describir el comportamiento del PDP-8 de Digital Equipment
Corporation (DEC). [55]
➢ 1979
La Universidad de Kaiserslautern produjo un lenguaje llamado KARL ("KAiserslautern
Register Transfer Language"), que incluía características de lenguaje de cálculo de diseño que
soportaban la planificación de piso de chips VLSI y el diseño de hardware estructurado. [55]
➢ 1980
Y A Block diagram Language (ABL) fue implementado a principios de la década de 1980 por
el Centro Studi e Laboratori Telecomunicazioni (CSELT) en Torino, Italia, produciendo el
editor de diseño gráfico ABLED VLSI. [55]
Mediados de 1980
Un consorcio internacional financiado por la Comisión de la Unión Europea implementó un
marco de diseño VLSI en torno a KARL y ABL. [55]
➢ 1983
El trabajo en Data General en 1980 utilizó estos mismos dispositivos para diseñar el Data
General Eclipse MV / 8000, y comenzó a crecer la necesidad comercial de un lenguaje que
pudiera mapearlos bien y Data I / O introdujo ABEL para satisfacer esa necesidad. [55]
➢ 1985
Cuando el diseño cambió a VLSI, Gateway Design Automation presentó el primer HDL
moderno, Verilog. [55]
➢ 1987
Una solicitud del Departamento de Defensa de EE. UU. Condujo al desarrollo de VHDL
(VHSIC Hardware Description Language). VHDL se basó en el lenguaje de programación
Ada, así como en la experiencia adquirida con el desarrollo anterior de ISPS. En unos pocos
años, VHDL y Verilog emergieron como los HDL dominantes en la industria electrónica,
mientras que los HDL más antiguos y menos capaces desaparecieron gradualmente del uso.
[55]
A lo largo de los años, se ha invertido mucho esfuerzo en mejorar las HDL. La última versión
de Verilog, conocida formalmente como IEEE 1800-2005 SystemVerilog. [55]
Características de los HDLS

Los lenguajes HDL deben ser multinivel, es decir, deben poseer la capacidad de utilizar el
rango más amplio posible de niveles de especificación y combinar estos niveles dentro de una
misma descripción para que así puedan ser utilizados junto con las herramientas de diseño.
[56]
Con la finalidad de simplificar la documentación el lenguaje deberá ser de fácil lectura y
comprensión. [56]
Es importante que el lenguaje tenga facilidad y potencia para describir los distintos elementos
que forman parte de un sistema digital. [56]
Los HDL deben poseer un conjunto de elementos, los cuales definirán una sintaxis
independiente del nivel en el que estemos. [56]
Los lenguajes HDL cuentan con la capacidad para realizar un diseño físico estructurado. Lo
cual debería facilitar la especificación de ciertos detalles de la realización física en una fase
temprana de diseño. [56]
Un HDL debe ser independiente de la tecnología en la cual se realice el circuito. [56]
Los lenguajes HDL deben ser capaces de simular la concurrencia. Ya que los componentes de
los sistemas digitales están activos simultáneamente. Por lo tanto, la concurrencia es un
aspecto fundamental a tener en cuenta. [56]
Para que sirven los HDLS
➢ Sirven para modelar circuitos, para expresar ideas y los modelos se pueden simular para
comprobar que se corresponden con la funcionalidad deseada. [55] [56]
➢ Se pueden sintetizar para crear un circuito que funcione como el modelo o se puede
construir el modelo de un circuito que ya exista, que ya esté implementado, es decir,
sintetizado. [55] [56]
➢ El objetivo es simular el circuito para comprobar que su funcionalidad se ajusta a las
especificaciones iniciales. [55] [56]
➢ Para generar documentación, siempre y cuando los modelos de los circuitos estén bien
comentados. [55] [56]
➢ Para crear bancos de prueba (test-bench), es decir, crear los estímulos y ver los resultados
durante la simulación. [55] [56]
VHDL
Definiciones de VHDL
Definición 1
El significado de las siglas VHDL es Very-High-Speed Integrated circuits Hardware
Description Language o bien lenguaje de descripción de hardware de circuitos integrados de
alta velocidad [57]
Definición 2
VHDL significa V HSIC (circuitos integrados de muy alta velocidad) Hardware Description
Language. A mediados de la década de 1980, el Departamento de Defensa de EE. UU. Y el
IEEE patrocinaron el desarrollo de este lenguaje de descripción de hardware con el objetivo
de desarrollar circuitos integrados de muy alta velocidad. [58]
Definición 3
VHDL es un lenguaje de especificación definido por el IEEE utilizado para describir circuitos
digitales y para la automatización de diseño electrónico. VHDL es acrónimo proveniente de
la combinación de dos acrónimos: VHSIC y HDL. [59]
Definición Grupal de VHDL

VHDL es un lenguaje de descripción de hardware, no es un lenguaje de programación,
aunque su sintaxis y forma de uso se asemeje mucho. Con VHDL no programamos, lo que se
hace es tomar un diseño electrónico y describirlo mediante el lenguaje, de forma que sirva
como punto de entrada a herramientas que convertirán esa descripción en una
implementación real del sistema.
Características de VHDL
➢ Sirve como herramienta de especificación de proyectos. [60]
➢ Permite generar proyectos con estructura del tipo jerárquica. [60]
➢ Posibilita modelizar el concepto de tiempo. [60]
➢ Permite describir módulos con acciones que serán evaluadas luego en forma secuencial.
➢ Permite la parametrización de componentes y portabilidad de los diseños para
independizarse de la tecnología. [60]
➢ Permite implementación de test-bench para simulación de diseños. [60]
➢ Documentación del diseño. En un principio, VHDL se estandarizo para la descripción
del hardware, pero no para su diseño. [60]
➢ Posee un diseño de alto nivel. [60]
➢ Descripción de entrada para las herramientas de diseño físico. [60]
¿Qué es una estructura en VHDL?
VHDL fue diseñado con base a los principios de la programación estructurada. Cada interfaz
define un módulo de hardware mientras deja invisible sus detalles internos. [61]
La entidad referenciada como ENTITY en VHDL es la declaración de las entradas y salidas
de un módulo mientras que la arquitectura referenciada como ARCHITECTURE en VHDL
es la descripción detallada de la estructura interna del módulo o de su comportamiento. [61]
¿Qué es una Entidad?

Permite la realización de diseños jerárquicos con el cual se defina la interfaz con el entorno
del sistema, conteniendo sus módulos interconectados y su diseño contendrá sus terminales
de entrada y salida. [62]
Las sentencias que se van a aplicar son opcionales, como lo es Generic, el cual define y
declara constantes y propiedades del módulo que está siendo señalado en la entidad, y a su
vez Port, define las entradas y salidas definidas en el módulo. [62]
Cada terminal se las puede declarar de cuatro formas como:
➢ Entradas simples
➢ Salidas simples
➢ Salidas retroalimentadas
➢ Terminales bidireccionales
Cada declaración se encontrará en la caja negra, donde estarán sus respectivas terminales de
la entidad. [62]
Ilustración 64.Entidad - Caja Negra [19]
¿Qué es una Arquitectura?
Consiste en la declaración que se le asigne permitiendo la definición de la función del circuito

que se empleara. [63]
La arquitectura contendrá siempre una entidad concreta, así que las declaraciones sin
especificar su entidad no las tomará en consideración. La entidad tiene diferentes
arquitecturas y es en la simulación donde se la especifica la síntesis de la arquitectura
concreta. [63]
➢ La palabra reservada of, se la define como el nombre de la descripción. [64]

➢ La palabra reservada is, se la define como el nombre del circuito. [64]
En las declaraciones se definen los subprogramas, declaraciones sean de tipo, de constantes,
de señales, de alias o de componentes, y cada asignación describe al circuito. [64]
Ilustración 65. ¿Qué es una estructura en VHDL? [18] [21]

MODELO COMPORTAMENTAL
En el modelado comportamental lo importante es la función que relaciona la salida con la
entrada.
El lenguaje VHDL permite escribir funciones complejas sin recurrir a su implantación física
con lo que se revela como una herramienta de gran rendimiento ya que proporciona una
potencia de diseño muy atractiva a un coste muy bajo [16].
Ilustración 66. Estructura Modelo Comportamental
VHDL suministra dos estilos para describir el comportamiento de un componente.

Flujo de datos: basado en sentencias de asignación concurrentes de señales.
Comportamental: el Proceso es usados para describir comportamientos mediante algoritmo
lenguaje a muy alto nivel [2].
Un Modelo comportamental puede suministrar un pequeño parecido a la implementación del
sistema.
No necesariamente implica estructura.
Ilustración 67. Estructura Modelo Comportamental
El bloque se conoce en VHDL como entidad y se declara en primer lugar una entidad indica
las señales que entran al circuito y las que salen, es decir, declara la relación del circuito con
el mundo exterior [22].
A cada entidad le corresponde al menos una descripción (comportamental, estructural)
aunque puede tener múltiples que se especifica en su arquitectura.
Ilustración 68. Estructura Entidad Modelo Comportamental
VHDL usa el siguiente ciclo de simulación para modelar los estímulos y respuesta natural del
Hardware digital.
Ilustración 69. Simulación para modelar estímulos
La descripción comportamental es la única disponible al más bajo nivel de modelado de

circuitos digitales (puertas lógicas) ya que no es posible fundamentarla en bloques más
básicos que ya serían los transistores [16].
Es una descripción comportamental donde la arquitectura declara simplemente la función que
relaciona salida con entradas. Dicha arquitectura contiene un único proceso.
El proceso cuenta con una sola sentencia de asignación de señal que corresponde a la
ecuación lógica de la puerta AND.
Ilustración 70. Descripción Arquitectura
MODELO ESTRUCTURAL VHDL
Definición 1
Según David G. Maxinez: “La descripción estructural basa su comportamiento en modelos
lógicos establecidos. (compuertas, sumadores, contadores, etc.) El usuario puede diseñar estas
estructuras y guardarlas para usarlas posteriormente o tomarlas de los paquetes contenidos en
las librerías del software”. [22]
Definición 2
Según Marcos Sánchez Élez: “La descripción estructural es utilizada para la creación de la
arquitectura de la entidad, entidades descritas y compiladas previamente, de esta manera en
VHDL podemos aprovechar diseños ya realizados o realizar diseños sabiendo que se
utilizaran en otros más complicados”. [23]
Definición 3
Según Fernando Pardo y José A. Boluda: “La descripción estructural está basada dentro de un
bloque de arquitectura donde la descripción es un poco más larga y menos clara ya que el
cuerpo de la arquitectura está compuesto por un netlist, es decir se ponen los componentes e
interconexiones, para los cuales se utilizarán entidades que ya están definidas en la
biblioteca”. [24]
Definición Grupal
La descripción estructural básicamente es crear la arquitectura en base a modelos lógicos ya
establecidos en el cual el usuario puede diseñar estructuras y guardarlas para después
volverlas a utilizar en diferentes trabajos o también se puede realizar en base a las librerías de
software que se estaría utilizando. [22] [23] [24]
Ejemplo:
Comparador de 2 bits
Ilustración 71. Comparador de 2 bits
En este ejemplo cada compuerta está dentro de un paquete gatespkg, del cual se toman para
estructurar el diseño. Esta arquitectura estándar se denomina componentes. Al
interconectarlos por señales internas (x0 y x1) permiten proponer una solución. En VHDL
esta conectividad se denomina netlist (listado de componentes). [22]
Paso para programar de forma estructural
Descomponer el problema en pequeños módulos. Dividir el problema hace de la descripción
estructura una forma sencilla de programar.
Ilustración 72. Descripción estructural de un comparador de igualdad de 2 bits
➢ En la siguiente imagen se puede demostrar cada una de las siguientes estructuras que se
usaron para su programación:
➢ Entre las líneas de la 3 a la 6 se definen entradas y salidas (a, b, c)
➢ En la línea 7 los componentes XOR y AND no se declaran pues se encuentran en el
paquete gatespkg, dentro de la librería de trabajo work.
➢ En la línea 8 se declara la arquitectura estructural.
➢ En la línea 9 las salidas de U_0 y U_1 (X_0, X_1). Declaradas dentro de la arquitectura y
no la entidad, pues no son un pin. Solo conectan de forma interna.
➢ Entre las líneas de la 11 a la 13 se encuentra el algoritmo propuesto, lo que permite que,
Cada compuerta se maneja como un bloque lógico independiente, del diseño original. Se
le asigna una variable temporal (U_0, U_1, U_2).
➢ Finalmente, la compuerta AND recibe X_0 y X_1, ejecuta la operación y asigna el
resultado a la salida c. [22]
METODOLOGIA DEL DISEÑO VHDL
Las metodologías de diseño comúnmente están basadas en las estrategias de las jerarquías de
TOP DOWN y BOTTOM-UP. Por medio del enfoque de arriba a abajo se pone atención
inicialmente en los aspectos globales de todo el sistema conforme el diseño progresa. El
sistema se descompone en subsistemas poniéndosele mayor consideración a los detalles
específicos. [25]
Diseño VHDL Bottom Up

Esta metodología de diseño comprende la descripción del circuito mediante componentes que
pueden agruparse en diferentes módulos, y éstos últimos a su vez en otros módulos hasta
llegar a representar el sistema completo que se desea implementar, empezando por describir
los componentes más pequeños del sistema para, más tarde, agruparlos en diferentes
módulos, y estos a su vez en otros módulos hasta llegar a uno solo que representa el sistema
completo que se pretende realizar. [26]
Ilustración 73. Metodología de diseño Bottom-Up [27]
Esta metodología consiste en reunir diferentes sistemas que conformaran un todo. Los
elementos individuales son especificados en gran detalle, los componentes se van uniendo
unos con otros hasta conformar un sistema final, que se logra al llegar al nivel superior”. Esta
estrategia asemeja al modelo “semilla”, en el cual se parte de algo pequeño que va creciendo
hasta llegar un sistema terminado y complejo. [28]
Ilustración 74. Metodología de diseño Bottom-Up [20]

Características Bottom Up
➢ Paralelización de la síntesis: Permite crear proyectos independientes para cada bloque, y

aprovecha recursos multi-cpu disponibles en el entorno de diseño lo que permite lanzarse
simultáneamente la síntesis de un alto número de bloques, minimizando el tiempo de
síntesis. [26]
➢ Disminución del tiempo de depurado: Permite separar la síntesis de cada bloque, durante
la etapa de depurado en la verificación RTL pueden realizarse modificaciones en un único
bloque y conseguir una nueva versión del diseño sin tener que sintetizar el resto de
bloques. [26]
Diseño Top-Down
El diseño Top-Down es, en su más pura forma, el proceso de capturar una idea en un alto
nivel de abstracción, e implementar esa idea primero en un muy alto nivel, y después ir hacia
abajo incrementando el nivel de detalle, según sea necesario. El sistema inicial se va
subdividiendo en módulos, estableciendo una jerarquía. Cada módulo se subdivide cuantas
veces sea necesario hasta llegar a los componentes primarios. [27]
Ilustración 75. Metodología del diseño Top-Down [27]
Esta metodología es una estrategia para procesar información y conocimiento. Se emplea en

diferentes áreas como: diseño de circuitos, desarrollo de productos, y de software. Este último
es el campo que más se ha beneficiado de esta metodología, permitiendo desmenuzar los
problemas en módulos que permiten que los programadores trabajen de manera más eficiente,
ya que los programas al estar divididos son más fáciles de leer y así es posible identificar los
errores. [29]
Ilustración 76. Metodología del diseño Top-Down [28]

Características
➢ Incrementa la productividad del diseño. Este flujo de diseño permite especificar

funcionalmente en un nivel alto de abstracción sin tener que considerar la implementación
del mismo a nivel de puertas lógicas.
➢ Incrementa la reutilización del diseño. En el proceso de diseño se utilizan tecnologías
genéricas. Esto es, que no se fija la tecnología a utilizar hasta pasos posteriores en el
proceso. Esto permite reutilizar los datos del diseño únicamente cambiando la tecnología
de implementación. Así es posible crear un nuevo diseño de uno ya existente.
➢ Rápida detección de errores. Como se dedica más tiempo a la definición y al diseño, se
encuentran muchos errores pronto en el proceso de descripción del circuito. [29]
8. Creación de un Proyecto
Creación de un Proyecto
Para crear un nuevo proyecto:
✓ Seleccionar File → New Project

✓ En la ventana de diálogo de New Project indicar el directorio de ubicación del
proyecto en Project Location
✓ Añadir el nombre en Project Name
✓ En la opción Top-Level Module Type se elige “Schematic” si el diseño se va a
realizar con esquemáticos o “HDL” si se va a utilizar un lenguaje de descripción del
hardware como VHDL.
Ilustración 77 Creación de Proyecto [Altamirano, M; Barreno, J; Cando, E]
Seleccionar la FPGA sobre la que se va a sintetizar el diseño

✓ Device Family: (familia)
✓ Device: (dispositivo dentro de la familia)
✓ Package: (encapsulado)
✓ Speed grade: (indica la velocidad máxima del dispositivo)
✓ Synthesis: (VHDL/Verilog)
✓ Simulator: (herramienta de simulación)
✓ Generated Simulation Language: VHDL (lenguaje asociado para los ficheros que
crea la herramienta)
Ilustración 78 Diseño Creación de proyecto [Altamirano, M; Barreno, J; Cando, E]
Añadir diseño en VHDL al proyecto
✓ Seleccionar Project → New Source

✓ Seleccionar VHDL MODULE
✓ En File Name le damos el nombre al diseño
✓ Se presiona Siguiente
Ilustración 79 Selección de Tipo [Altamirano, M; Barreno, J; Cando, E]
✓ Se presiona Finalizar para concluir

Ilustración 80 Definición de entradas [Altamirano, M; Barreno, J; Cando, E]
:
Entorno de Programación
Partes del programa ISE DESING SUITE
Ilustración 81 Entorno de Programación [Altamirano, M; Barreno, J; Cando, E]
Creación del código funcional
Un módulo VHDL consiste de:

✓ Declaración de las bibliotecas a utilizar
✓ Declaración de Puertos (Entidad)
✓ Descripción funcional del módulo (Arquitectura)
Las plantillas proporcionan fragmentos de código predefinidos y sintaxis de código para usar
en sus archivos de fuente.
Ilustración 82 Plantillas [Altamirano, M; Barreno, J; Cando, E]
En concreto la ventana de procesos incorpora todas las opciones necesarias para realizar
todos los pasos de implementación de sistemas de lógica programable, incluyendo la edición
y verificación.
Entorno de Modelado
MODELADO RTL. - Esquema se genera después de la fase de síntesis de HDL del proceso
de síntesis. Muestra una representación del diseño pre-optimizado en términos de símbolos
genéricos como: sumadores, multiplicadores, contadores, compuertas AND y OR, que son
independientes del dispositivo Xilinx seleccionado [65].
MODELADO TECHNOLOGY.- Este esquema se genera después de la fase de

optimización de tecnología y objetivo del proceso de síntesis. Muestra una representación del
diseño en términos de elementos lógicos optimizados para el dispositivo o tecnología de
Xilinx de destino. Al visualizar este esquema nos permite ver una representación a nivel
tecnológico de su HDL optimizada para una arquitectura Xilinx específica, que podría ayudar
a descubrir problemas de diseño al principio del proceso de diseño [65].
Ilustración 83 Entorno de Modelado [Altamirano, M; Barreno, J; Cando, E]

Entorno de Simulación
Ilustración 84 Entorno de Simulación [Altamirano, M; Barreno, J; Cando, E]
Una vez que arranque observaremos la siguiente pantalla:
Ilustración 85 Ventana Entorno de Simulación [Altamirano, M; Barreno, J; Cando, E]
✓ El cuadro de instanciación y procesos muestra la arquitectura del programa y su jerarquía

interna
✓ El cuadro de objetos de la instanciación aparecerá las señales de la instancia o proceso
seleccionado
Forzado de Variables
Ilustración 86 Forzado de Variables [Altamirano, M; Barreno, J; Cando, E]
Test Bench
Para simular un diseño es necesario generar estímulos para todas las entradas el que será
proporcionado por el banco de pruebas. Un banco de pruebas es un código HDL que permite
proporcionar un conjunto de estímulos documentados y repetibles además de que es portátil
en diferentes simuladores. Un banco de pruebas puede ser tan simple como un archivo con
reloj y datos de entrada o un archivo más complicado que incluye verificación de errores,
entrada y salida de archivos y pruebas condicionales. Para su utilización se debe crear un
módulo adicional denominado Test Bech además del módulo VHDL cotidiano, el cual sirve
para la asignación de un conjunto de datos [66].
Ilustración 87 Test Bench [Altamirano, M; Barreno, J; Cando, E]
Dentro de la programación se debe realizar la asignación de los tiempos, se asignan los

valores y tiempos para cada grupo de variables o variable.
Ilustración 88 Asignación de Valores/ Tiempos [Altamirano, M; Barreno, J; Cando, E]
VHDL
Como todos sabemos VHDL es un lenguaje de descripción de circuitos electrónicos digitales

que utilizan distintos niveles de abstracción, este no es un lenguaje de programación por eso
conocer su sintaxis no implica necesariamente saber diseñar con él, VHDL sería más un
lenguaje de descripción de hardware, el cual nos permite describir circuitos síncronos y
asíncronos. [3]
En VHDL la parte exterior es decir cuántos puertos de entrada y salida tenemos se denomina
entity y la descripción del comportamiento del circuito de denomina architecture. [3]
Entity es la abstracción del circuito puede ser desde un complejo sistema electrónico hasta
una simple puerta lógica, este describe la forma externa del circuito en la cual están
enumeradas las entradas y salidas del circuito, además tiene la información necesaria para
conectar un circuito a otros circuitos. Los puertos pueden ser de entrada in, salida out,
entrada-salida inout o buffer. [3]
Architecture se utiliza para representar la descripción completa de un diseño, también
describe el funcionamiento de la entidad a la que hace referencia, utilizando sentencias y
expresiones propias de VHDL, aquí es donde se escriben todas las sentencias que describen el
comportamiento del circuito. [3]
Modelo estructural
Esta descripción utiliza para la creación de la arquitectura de entidades descritas y compiladas

previamente, de esta manera en VHDL podemos aprovechar diseños ya realizados, o realizar
diseños sabiendo que se utilizarán en otros más complicados. Así se ahorra trabajo al
diseñador-programador. Se declaran los componentes que se van a utilizar y después,
mediante los nombres de los nodos, se realizan las conexiones entre los puertos. Las
descripciones estructurales son útiles cuando se trata de diseños jerárquicos botton-up. [3]
Se pueden utilizar tantos componentes como necesite el diseño, estos componentes son
entidades anteriormente declaradas o compiladas, subcircuito debe ser el nombre de una
entidad que se ha declarado anteriormente en el código o que se ha compilado como parte de
otro fichero VHDL. Se puede utilizar un componente tantas veces como sea necesario. [3]
Podemos realizar un diseño estructural puro, mediante la unión de componentes que
describen las distintas funcionalidades del circuito, en el que necesitaremos definir las señales
intermedias entre las que se encontrará siempre las señales que interconectan las salidas de
los módulos con las salidas de la entity. [3]
Ilustración 89: Diseño estructural [3]
Dentro de la descripción estructural de un circuito aparece la sentencia GENERATE, ésta se

utiliza para poder generar de forma automática un array de interconexiones mediante
instrucciones de asignación o componentes. Es decir, generate, permiten crear varias copias
de un conjunto de interconexiones de manera análoga a la utilización de un for en otros
lenguajes. La sentencia for-generate siempre va fuera de los process. [3]
El resultado final de la utilización de la sentencia generate, tanto en simulación como en
síntesis, es el desenrollado del bucle y su ejecución como si fueran N asignaciones diferentes
que se realizan en paralelo. [3]
Ilustración 90: Sentencia Generate [3]

Se pueden encadenar tantos bucles como sea necesario para la correcta descripción del
circuito. Además, La sentencia generate permite la utilización de la construcción if siempre
que ésta vaya asociada al índice del for y no a ningún otro factor. [3]
Port Map
La cláusula PORT MAP declara las conexiones. Si PORT fuera una declaración local, PORT
MAP sería una forma de declaración global. En realidad, cada instanciación de un
componente puede ser vista como una llamada a su proceso y, por tanto, a una sentencia
concurrente como sucedía en el modelado comportamental. Si la instancia es también una
descripción estructural, llamará a los procesos correspondientes de un nivel jerárquico
inferior y así sucesivamente hasta encontrar algún modelo comportamental puro. [4]
La lista de conexiones del PORT MAP debe realizarse en el orden en el que las señales se
declararon en la entidad si se hace implícitamente. Si se hace explícitamente no es necesario.
[4]
Ilustración 91 Circuito de ejemplo para PORT MAP. [4]
Ilustración 92 Descripción del circuito de ejemplo para PORT MAP. [4]
10. Convertidor de código
¿Qué es un código?
Es un conjunto de reglas, o una serie de símbolos que por separado no representan nada, pero
al combinarlos pueden generar un lenguaje comprensible solo para aquellos quienes lo
entiendan. [1]
Se puede acotar que las reglas son las que hacen que cambie la representación de la
información, mas no la función.
¿Qué es un conversor de código o convertidor de código?

Se puede decir que un conversor de código es un elemento lógico que traduce una palabra de
“n” bits a otra de “m” bits, las cuales se refieren al mismo valor decimal, pero en distintos
códigos. [5]
Es una aplicación diseñada con diferentes elementos, lo que hace es convertir un código en
otro que tenga exactamente el mismo valor, pero con representación totalmente distinta.
Código binario natural.

Consiste en representar directamente el número decimal en binario, o lo que es lo mismo cada
número decimal tiene su correspondiente en binario. Ejemplo 35(10) = 100011(2). [1]
Códigos BCD (Decimal codificado en binario)

Con estos códigos, para representar un número decimal en binario, se transforman cada una
de las cifras que constituyen el número decimal separadamente, en el caso anterior el número
35, transformado en binario sería el resultado de transformar primero 3, y después 5. [1]
Código BCD natural (8421)
Es un código con peso o ponderado, es decir el número decimal equivalente es el resultado de
sumar el valor de la posición de los dígitos binarios que constituyen el código. En este código
los pesos de los dígitos son las potencias sucesivas de dos, es decir 23 (8), 22 (4), 21 (2) y 20
(1), como se puede observar de ahí viene el nombre del código. Es decir, se transcriben las
cifras decimales a binario y viceversa, según la posición que ocupan. Ejemplo 35 = 0011
0111. Es decir 3 (0011) y 5 (0101). [23]
Código Aiken (2421)

También es un código ponderado, aunque ahora los pesos de las cifras según su posición
serán: 2, 4, 2 y 1. Ejemplo 35 = 0011 1011. Es decir 3 (0011) y 5 (1011). [23]
Código exceso tres

Éste es un código no ponderado, para obtener la relación entre el código decimal y este
binario, se suma a cada dígito tres y después se convierte el resultado obtenido en binario
8421. Ejemplo 35 = 0110 1000. Es decir 3 (0110) y 5 (1000). [23]
Código Grays
El código binario Gray, es un sistema de numeración binario en el que dos números
consecutivos difieren solamente en uno de sus dígitos, fue diseñado originalmente para
prevenir señales ilegales de los switches electromecánicos, y actualmente es usado para
facilitar la corrección de errores en los sistemas de comunicaciones, tales como algunos
sistemas de televisión por cable y la televisión digital terrestre. [23]
Ilustración 89:Tabla Conversión de Códigos [23]
MODELADO ESTRUCTURAL
Componentes de una descripción estructural
En una descripción estructural, los componentes se comunican entre si a través de señales. Un

componente puede ser un sistema individual especificado por medio de su Entidad y
Arquitectura, o bien puede ser insertado en la arquitectura con la palabra reservada
component.
✓ Los componentes deben ser instanciados en la descripción estructural.
✓ La instanciación de componentes es una proposición básica en una arquitectura
estructural.
✓ Las diferentes instancias son concurrentes una con otra. Un componente instanciado no
está completo sin un mapa de sus puertos – una referencia de cómo se hará la conexión
entre los puertos del componente con las señales del nivel jerárquico más alto. [24]
Procesos de instanciación
Componentes e instanciación directa de componentes
Antes de que un componente pueda ser usado, éste debe ser instanciado. La instanciación
consiste en seleccionar una especificación compilada de la librería y ligarla a la arquitectura
donde será usada.
Cada instancia de un componente contiene dos partes: [23]
nombre_de_la_instancia: entity work.nombre_de_la_entidad (

nombre_de_la_arquitectura )
Instanciación directa
✓ Es la forma más simple de construir un sistema estructuralmente.

✓ Se requiere la especificación compilada del componente a instanciar y la proposición
con la instanciación.
✓ El nombre de la arquitectura es obligatorio cuando la entidad a instanciarse tiene
asociadas más de una arquitectura. En otro caso, puede omitirse. [3]
Instanciación por componente
✓ Para diseños grandes sería conveniente que todos los módulos se pudiesen hacer por
separado y que se pudiera hacer referencia a otros componentes cuyo comportamiento no
ha sido aún especificado. [1]
✓ Para una especificación estructural sería suficiente con tener una declaración de la interfaz
del componente (como requisito del sistema) [1]
✓ La declaración de la interfaz del componente es llamada declaración del componente
(component declaration) y es ubicada en la parte declarativa del cuerpo de la arquitectura
(o en un paquete) [1]
Específica como las E/S del componente declarado (usando la declaración de componente
explicada previamente), son conectadas en el diseño en que se utiliza el componente.
1. -- a)instanciacion de componente con asociacion posicional

2.
3. U1: register port map (sys_clk, sys_rst, data_bus, reg_data);
4.
5.
6. -- b) instanciacion de componente con asociacion por nombre
7.
8. U1: register port map (
9.
10. clk => sys_clk,
11. rst => sys_rst,
12. d_b => data_bus,
13. reg => reg_data
14.
15. );
16. -- c) instanciación en VHDL-2008 (sin declaración de componente)
17. U1: entity work.register port map (
18. clk => sys_clk,
19. rst => sys_rst,
20. d_b => data_bus,
21. reg => reg_data
22. );
En la instanciaciónón por posición, la lista de conexiones se hace en el mismo orden en que

los puertos fueron declarados en la entidad del componente instanciado. Se aconseja el uso
de asociación por nombre, ya que es menos propensa a errores. En este caso también se
aconseja separar las asociaciones por funcionalidad más que por si son entradas o salidas. [5]
Declaración de componentes
La sintaxis para la declaración de componentes es muy similar a la declaración de entidades,

esto no es coincidencia puesto que los componentes y las entidades juegan un papel similar
en la definición de módulos externos. [1]
Sintaxis:
1. component nombre_del_componente is
2. generic ( lista de parámetros );
3. ports ( lista de puertos );
4. end component nombre_del_componente;
La declaración de un componente por otro lado define la interfaz de un módulo “virtual” o

que “no-existe”; es especificado dentro de una arquitectura como para indicar que ahí se va a
situar al componente “real”. [5]
Para usar un componente ya definido (entity/architecture), que va pasar a ser un sub-
componente, en un nuevo componente es necesario primer declarar el componente a usar, y
luego instanciarlo. Una declaración de componente simplemente específica la interface de
E/S del componente mediante el uso de los puertos de E/S (I/O ports), y los generics. [5]
1. -- declaracion de component
2. component register
3. generic(bus);
4. port (
5. clk: in std_logic;
6. rst: in std_logic;
7. d_b: in std_logic_vector(bus-1 downto 0);
8. reg: out std_logic_vector(bus-1 downto 0)
9. );
10. end component;
Nota: cuando la cantidad de declaración de componentes sea

un número considerable, es aconsejable declarar los componentes en un paquete. De este
modo el código en sí queda más ordenado, limpio, y fácil de seguir. De todos modos, a partir
de VHDL-2008 no hace falta la declaración de componentes si la sintaxis de la instanciación
de componentes es similar a la que se detalla en el ejemplo debajo.
Port map
Los puertos en una declaración de componente generalmente deben coincidir con los puertos
en la declaración de entidad uno por uno. La declaración del componente define los nombres,
el orden, el modo y los tipos de puertos que se utilizarán cuando el componente se instale en
el cuerpo de la arquitectura. Instalar un componente implica hacer una copia local de la
entidad de diseño correspondiente: un componente se declara una vez dentro de cualquier
arquitectura, pero se puede crear una instancia varias veces. [67]
SINTAXIS:
1. port map ( [ port_name => ] expression, ... )
DESCRIPCIÓN:
Un mapa de puertos asigna señales en una arquitectura a puertos en una instancia dentro de
esa arquitectura. Los mapas de puertos también pueden aparecer en un bloque o en una
configuración.
Las conexiones se pueden enumerar mediante asociación posicional o mediante asociación
con nombre. Dentro de una instancia, los nombres de los puertos son puertos en el
componente o entidad que se está instanciando, las expresiones son señales visibles en la
arquitectura que contiene la instancia. Dentro de una configuración, los nombres de puerto
son puertos en la entidad, las expresiones son puertos en el componente. Los elementos de un
puerto de matriz se pueden conectar individualmente cuando se usa una asociación con
nombre.
Los puertos se pueden dejar desconectados usando la palabra clave open. [67]
Atributos – Uso de Event para señal CLK
ATRIBUTOS
Los elementos como señales y variables pueden tener atributos, éstos se indican a
continuación del nombre, separados con una comilla simple " ' " y pueden incluir información
adicional de algunos objetos desarrollados en VHDL, que servirán a las herramientas de
diseño para obtener información a la hora de realizar una síntesis. [5]
Existen muchos atributos, como LEFT, RIGHT, LOW, HIGH, RANGE, LENGTH... Pero el
atributo más usado es EVENT, que indica si una señal ha cambiado de valor. Por ejemplo la
siguiente sentencia captura un flanco de subida de una señal (clk). [5]
....
if clk'event and clk = '1' then
....
Definición de atributos
Un atributo definido por el diseñador siempre devolverá un valor constante. En primer lugar
se debe declarar el atributo, mediante la palabra reservada ATTRIBUTE, indicando el tipo de
elemento que se devuelve, seguidos el valor que se retornará. [67]
La sintaxís para definir atributos sería la siguiente.
ATTRIBUTE nombre : tipo

ATTRIBUTE nombre OF id_elemento : clase IS valor
Donde nombre es el identificador del atributo, id_elemento corresponde al identificador de
un elemento del lenguaje definido previamente (señal, variable, etc.), la clase es el tipo de
elemento al que se le va añadir dicho atributo, es decir si es señal, constante, etc. y el valor
será lo que devuelva al preguntar por dicho atributo. Un ejemplo de todo esto puede ser el
siguiente. [67]
SIGNAL control : std_logic;

ATTRIBUTE min : integer;
ATTRIBUTE min OF control : SIGNAL IS 4;
....
IF control'min > 20 THEN
Nota: s’event devuelve true si se ha producido un cambio en la señal s s’stable(tiempo)

devuelve true si la señal ha estado estable durante tiempo.
La palabra EVENT es un atributo que se utiliza en las señales para determinar que ha
ocurrido un cambio en el valor de la señal.
Flujo de diseño con VHDL

Una jerarquía de interconexiones dentro de la programación permite a los componentes
interconectarse según la necesidad del diseñador del sistema, es algo similar a un proceso de
manufactura entre el usuario y el diseñador para poder encontrar solución a algún problema o
desempeñar alguna función lógica necesaria. En los ejercicios resueltos y propuestos que se
presentan a continuación se observa el modelado estructural en el que se utiliza la
instanciación de componentes y más unidades de diseño aptos para la solución del ejercicio
planteado.
SISTEMA DE CALCULO DE COMPLEMENTO A1 Y COMPLEMENTO A2

El complemento a 1 y a 2 de un número binario son importantes porque permiten la
representación de números negativos. El método de complemento a 2 en aritmética es
comúnmente usada en computadoras para manipular números negativos
DISEÑO DE UNA MAQUINA DE ESTADOS
VHDL permite realizar descripciones algorítmicas de máquinas de estados en el que el
diseñador evita tareas como general la tabla de transición de estados o la obtención de las
ecuaciones de excitación basadas en un tipo de biestable. Existen varias formas de
implementarla sin embargo es indispensable obedecer dos normas como: La una siempre
debe existir un reset para inicializar la máquina de estados y la segunda que dentro del case
del process combinacional siempre se debe dar un valor al estado siguiente bajo cualquier
condición
DISEÑO DE UN GENERADOR DE CODIGO

La generación del código se considera una de las partes más importantes mediante la cual se
permite convertir un programa en una serie de instrucciones que son interpretadas por una
máquina, la entrada viene delimitada por una cadena de bits de ingreso que son seleccionadas
por medio de instrucciones con el fin de poder construir un código en específico utilizado
para múltiples funciones en específico.
Sistemas Embebidos con dispositivos FPGA con National Instruments
Atributos
Los atributos son las características individuales que diferencian un objeto de otro y
determinan su apariencia, estado u otras cualidades. Los atributos se guardan en variables
denominadas de instancia, y cada objeto particular puede tener valores distintos para estas
variables [68].
Las variables de instancia también denominados miembros dato, son declaradas en la clase,
pero sus valores son fijados y cambiados en el objeto [68].
Además de las variables de instancia hay variables de clase, las cuales se aplican a la clase y a
todas sus instancias. Un ejemplo de esto tenemos el número de ruedas de un automóvil es el
mismo cuatro, para todos los automóviles [68].
Ilustración 90: Atributos
Principales atributos
S’EVENT
Retorna verdadero si ocurrió un evento en S durante el corriente delta, de lo contrario
devuelve falso
S’ESTABLE
Retorno verdadero si no hay evento S
S’ACTIVE
Retorno verdadero si S=1
S’LAST_EVENT
Retorna el tiempo transcurrido desde la transición previa de la señal S
S’LAST_VALUE
Retorna el valor previo de S antes del ultimo evento
S’LAST_ACTIVE
Retorna el tiempo transcurrido desde la transacción previa de la señal
Atributo Event
El atributo event (evento, donde ‘indica que se trata de un atributo”) se utiliza para describir
un hecho u ocurrencia de una señal particular. Considerando una señal de reloj (CLK), la
sentencia CLK’event es cierta sólo cuando ocurre un cambio de valor (paso de ‘0’ a ‘1’ o de
‘1’ a ‘0’). Combinándola con una sentencia de comprobación de igualdad del nuevo valor es
posible definir la activación por el tipo de flanco que se desee [69]:
Modelado de Sistemas Secuenciales

En general, un circuito secuencial está compuesto por circuitos combinacionales y elementos
de memoria. Se dice que en un circuito secuencial la salida actual depende de la entrada
actual y del estado actual del circuito [69].
Ilustración 91: Modelado sistema secuencial [69].
Descripción lógica secuencial

➢ Uno de los conceptos nuevos que aparece en VHDL a la hora de describir sistemas
secuenciales es la forma de describir la activación por flanco de reloj [69].
➢ Atributo ‘EVENT [69].
➢ En el lenguaje VHDL los atributos sirven para definir características que se pueden
asociar con cualquier tipo de datos, objeto o entidades [69].
➢ El atributo event (evento, donde indica que se trata de un atributo) se utiliza para describir
un hecho u ocurrencia de una señal particular [69].
➢ La principal opción que ofrece VHDL para modelar la activación por flanco en los
circuitos secuenciales es mediante el atributo ‘event. Sin embargo, es posible modelarlos
también mediante dos formas adicionales [69]:
➢ Dentro de un proceso con la sentencia WAIT UNTIL [69].
➢ Usando las macros VHDL’93 rising_edge(señal) y falling edge(señal) [69].
Ilustración 92: Modelado la activación por flanco [69].
Sistemas Embebidos en base a FPGA de National Instruments
Definición
National Instruments (NI) es una empresa que transforma la manera en cómo los ingenieros e
investigadores diseñan, generan prototipos e implementan sistemas para aplicaciones
embebidas, de medidas y de automatización. El objetivo de esta empresa es que sus clientes
desarrollen continuamente tecnologías innovadoras que impacten a millones de personas ya
sea desde la programación de sistemas de juegos de la próxima generación hasta la creación
de nuevos dispositivos médicos [70].
Ilustración 93: National Instruments-Logo (Antes y Después)
Historia
National Instruments (NI) es una empresa fundada en 1976 por James Truchard, Bill Nowlin
y Jeff Kodosky en Austin, Texas. Esta empresa comenzó su historia en el garaje de James
Truchard trabajando en productos relacionados con GPIB. En la década de los 80 juntos
crearon su principal producto al cual llamaron LabVIEW [71].
Desde entonces la empresa se dedica al desarrollo y venta de productos de software, hardware
y servicios. Sus mercados tradicionales son los campos de adquisición de datos, control de
instrumentos e instrumentación virtual. En los últimos años también ha extendido su negocio
a sistemas de comunicaciones y sistemas embebidos, en buena parte apoyándose en las
arquitecturas PXI y CompactRIO [71].
LabVIEW
Definición
LabVIEW es un software de ingeniería de sistemas para aplicaciones que requieren pruebas,
medidas y control con acceso rápido a hardware e información de datos [72].
Ilustración 94: LabVIEW
Función
LabVIEW ofrece un enfoque de programación gráfica que le ayuda a visualizar cada aspecto
de su aplicación, incluyendo configuración del hardware, datos de medidas y depuración.
Esta visualización simplifica la integración del hardware de medidas de cualquier proveedor,
representa una lógica compleja en el diagrama, desarrolla algoritmos de análisis de datos y
diseña interfaces de usuario de ingeniería personalizadas [73].
Características
Presenta facilidades para el manejo de:
• Interfaces de comunicaciones:
➢ Puerto serie
➢ Puerto paralelo
➢ GPIB
➢ PXI
➢ VXI
➢ TCP/IP, UDP, DataSocket
➢ Irda
➢ Bluetooth
➢ USB
➢ OPC...
• Capacidad de interactuar con otros lenguajes y aplicaciones:
➢ DLL: librerías de funciones

➢ .NET
➢ ActiveX
➢ Multisim
➢ Matlab/Simulink
➢ AutoCAD, SolidWorks, etc
• Herramientas gráficas y textuales para el procesado digital de señales.

• Visualización y manejo de gráficas con datos dinámicos.
• Adquisición y tratamiento de imágenes.
• Control de movimiento (combinado incluso con todo lo anterior).
• Tiempo Real estrictamente hablando.
• Programación de FPGAs para control o validación.
• Sincronización entre dispositivos.
DE_FPGA_Board
Equipos DE (Digital Electronic) FPGA board NI
La placa FPGA de NI Digital Electronics es una plataforma de desarrollo de circuitos basado

en el FPGA XC3S500E Xilinx Spartan-3E. Además de la FPGA, la placa contiene
interruptores deslizantes, LED, un segmento de dos dígitos y siete pantalla, pulsadores, botón
giratorio y LED para un dispositivo externo reloj, terminales Digilent Pmod para accesorios
externos, descarga USB Interfaz y área de tablero grande para circuitos electrónicos digitales
experimentación [74]
Estructura
Ilustración 95 Estructura DE FPGA Board
Ilustración 96 DE FPGA Board
NI ELVIS II
En el modo NI ELVIS, la placa FPGA de NI Digital Electronics se puede utilizar como una
placa de creación de prototipos en una estación de trabajo NI ELVIS II Series. Instale y
configure la placa FPGA de NI Digital Electronics y NI ELVIS II Donde las instrucciones de
instalación de la Serie NI ELVIS II :
2. Conecte un
extremo del cable 4. Encienda la
1. Inserte la Tarjeta
USB de la FPGA 3. Encienda la placa FPGA de NI
FPGA de NI
al conector USB de estación de trabajo Digital Electronics
Digital Electronics
FPGA Board, y al NI ELVIS II moviendo la
como una tarjeta
otro extremo al Series. cambie a la
de prototipos
conector USB de la posición ON.
PC host.
(Windows XP) Windows reconoce cualquier dispositivo recién instalado

La primera vez que la computadora se reinicia después de instalar el hardware. En algunos
Windows, el Asistente para hardware nuevo encontrado se abre con un cuadro de diálogo
para cada dispositivo NI instalado. Instalar el software automáticamente (recomendado) está
seleccionado de forma predeterminada. Haga clic en Siguiente o Sí para instalar el software
del dispositivo y los puertos del cable USB. El LED verde LD-G se enciende, lo que indica
una buena conexión [74].
Ilustración 97 NI ELVIS II
ARQUITECTURA DE LOS SISTEMAS EMBEBIDOS CON FPGA

¿Qué es RIO?
RIO significa E / S reconfigurable y describe una tecnología utilizada en muchos productos

de hardware de NI. Los productos RIO cuentan con un procesador y FPGA, los cuales son
completamente programables usando el software NI LabVIE.
Entre ellos se encuentran:
SbRio
Un dispositivo NI Single-Board RIO (sbRIO) consiste en un procesador en tiempo real
conectado a un FPGA reconfigurable , con 110 líneas de E / S digitales (DIO) y tres ranuras
de expansión para módulos de la Serie C. Los dispositivos NI sbRIO-961x, NI sbRIO-963x y
NI sbRIO-964x tienen líneas de E / S adicionales provistas por módulos de la Serie C
integrados.
La FPGA reconfigurable por el usuario controla las líneas de E / S digitales y analógicas en el
dispositivo sbRIO. Puede configurar el dispositivo sbRIO y usar el Módulo LabVIEW FPGA
y NI-RIO para crear y descargar un VI personalizado a la FPGA para definir el tiempo y la
funcionalidad del dispositivo sbRIO. Si solo tiene LabVIEW y NI-RIO pero no el Módulo
FPGA, no puede crear nuevos VIs FPGA, pero puede crear VIs que se ejecuten en Windows
o un objetivo LabVIEW Real-Time (RT) para controlar VIs FPGA existentes.
Utilice este libro como referencia para obtener información sobre las funciones de E / S de
FPGA , los recursos de E / S, las opciones de arbitraje, los métodos y las propiedades que
admite cada dispositivo sbRIO. [74]
Ilustración 98 Sb-Rio c-Rio [73]

MY_RIO
Definición. -
Es un dispositivo portable hardware embebido desarrollado por National Instruments y
programable por la herramienta software LabVIEW. Se puede utilizar para diseñar sistemas
de control, robótica y mecatrónica. También incluye una antena WI-FI integrada que permite
al usuario transferir datos inalámbricamente y desplegar código. En la ilustración 4 se
muestra las partes que conforman myRIO. [75]
El procesador puede ser programado bien por C++, o bien en LabVIEW. En cambio, la
FPGA solo puede ser programada por el entorno de LabVIEW.
Estructura. -
SB_RIO
Definición. -
Los controladores Single-Board RIO incluyen placas computadoras y System-on-Module
(SOM) robustos y pequeños que ofrecen la flexibilidad de una solución personalizada para
cumplir con los requerimientos de su proyecto, con la productividad de un producto
comercial. Cada controlador se vende con un paquete completo de middleware que incluye
Linux Real-Time, controladores de E/S y soporte para múltiples entornos de programación,
incluyendo LabVIEW [76].
Estructura
Elementos de una tarjeta SB rio 9627
Ilustración 99: SB rio 9627 [76].
Los controladores CompactRIO de placa única cuentan con un sistema totalmente

programable en chip (SoC) que contiene dos unidades de procesamiento:
1. Un procesador en tiempo real para comunicación y procesamiento de señales [76].
2. Un FPGA para implementar control de alta velocidad y temporización personalizada y
disparar directamente en el hardware [76].
Ilustración 100: arquitectura heterogénea de CompactRIO [76].
Estructura de un sistema embebido en LabVIEW

Entre las características funcionales más significativas están:
• Ofrece la capacidad para reutilizar algoritmos embebidos ya existentes o software embebido
desarrollado previamente.
• Incluye controladores de componentes completamente integrados para convertidores ADI
• Se enfoca en la familia de procesadores embebidos Blackfin de baja potencia y alto
rendimiento
• Proporciona una solución completamente integrada desde la formación del concepto hasta el
despliegue
En la figura se muestra la estructura jerárquica correspondiente a las distintas fases de diseño con
este módulo. [77]
Ilustración 101: Estructura jerárquica de diseño [78].
Este módulo LabVIEW Embedded Module for Blackfin Processors es compatible con todos los
emuladores JTAG de Analog Devices y se dispone de los siguientes modelos [78]:
• NI LabVIEW Embedded Modulefor ADI Blackfin Processors Bundle [78].

• NI LabVIEW Embedded Modulefor ADI Blackfin Processors Bundle SSP [78].
• NI LabVIEW Embedded Modulefor ADI Blackfin Processors [78].
• NI LabVIEW Embedded Modulefor ADI Blackfin Processors with SSP [78].
• SSP, LabVIEW Embedded Modulefor Blackfin Processors [78].
Configuración de un sistema remoto FPGA en LabVIEW

Configurar el NI MAX, para que reconozca el dispositivo FPGA [77].
Ilustración 102: Configuración NI MAX
Luego se definen las máscaras de red para ello se configura las direcciones IP, creándose así la
conexión de red entre la computadora y el sistema remoto [77].
Ilustración 103: Configuración mascara de red y dirección IP
En Max se deben seguir los siguientes pasos para la configuración en Matlab [77]:
• Verificar su reconocimiento bajo la sección Remote Systems [77].
• Verificar el software instalado [77].
• En caso de ser necesario, reinstalar el software añadiendo las herramientas que se
utilizaran [77].
Ilustración 104: Configuración de NI MAX [77].
Para la comunicación de myRIO con la PC se tiene en cuenta los siguientes parámetros:

• LabVIEW referenciado al myRIO mediante un IP [77].
• USB, se crea un puerto virtual Ethernet con IP predeterminada [77].
• WIFI, configurar en MAX bajo Network Settings [77].
Ilustración 105: Configuración myRIO con la PC [77].
Ahora bien, configuramos el dispositivo dentro de labview para ellos me voy a la selección
del entorno, realizo la configuración del proyecto y al final ya aparece myRIO [77].
Ilustración 106: Configuración del dispositivo dentro de labview [77].
Dentro del choose enviroment ya se nos va a crear un proyecto para labview FPGA aquí
creamos el entorno para trabajar [77].
Ilustración 107: Creacion proyecto Labview FPGA [77].

Paquete LabVIEW FPGA
Función
El Módulo NI LabVIEW FPGA extiende la plataforma de desarrollo gráfico de LabVIEW
para programar FPGAs en hardware de E/S reconfigurables (RIO) de NI. LabVIEW FPGA
también brinda a los desarrolladores la habilidad de diseñar de manera más eficiente y
efectiva sistemas complejos al proporcionar un entorno de desarrollo altamente integrado, un
gran ecosistema de bibliotecas de IP, un simulador de alta fidelidad y características de
depuración [77].
Ilustración 108: Paquete LabVIEW FPGA
Características
Graphical System Design
LabVIEW FPGA ofrece un enfoque de programación gráfica que simplifica la tarea de
conectar a E/S y comunicar datos, mejorando enormemente la productividad del diseño y
reduciendo el tiempo al mercado [77]
Reutilización de Código HDL y Bibliotecas de IP

LabVIEW FPGA ofrece IP desarrollado por NI y Xilinx para funciones básicas como
contadores o algoritmos más avanzados como decodificación de video. Se puede importar y
reutilizar código HDL existente con el Nodo de Integración IP [77].
Rápido Desarrollo de Algoritmos

LabVIEW FPGA está completamente equipado con habilidades integradas de simulación y
herramientas de depuración, así se puede detectar el mayor número de errores de
implementación como sea posible antes de la compilación. Dentro de la simulación, se puede
depurar el código con funciones de depuración de LabVIEW básicas como ejecución
resaltada, puntos de interrupción y puntas de prueba [77].
Proceso de compilación de VIs para FPGA
Los programas en LabVIEW son llamados instrumentos virtuales (VIs) Para los amantes de
lo complejo, con LabVIEW pueden crearse programas de miles de VIs (equivalente a
millones de páginas de código texto) para aplicaciones complejas, programas de
automatizaciones de decenas de miles de puntos de entradas/salidas, proyectos para combinar
nuevos VIs con VIs ya creados, etc. Incluso existen buenas prácticas de programación para
optimizar el rendimiento y la calidad de la programación [79].
Cada VI consta de dos partes diferenciadas:
 Panel Frontal: El Panel Frontal es la interfaz con el usuario, se la utiliza para interactuar
con el usuario cuando el programa se está ejecutando. Los usuarios podrán observar los
datos del programa actualizados en tiempo real (como van fluyendo los datos, un ejemplo
sería una calculadora, donde tú le pones las entradas, y te pone el resultado en la salida).
En esta interfaz se definen los controles e indicadores [79].
 Diagrama de Bloques: es el programa propiamente dicho, donde se define su

funcionalidad, aquí se colocan íconos que realizan una determinada función y se
interconectan (el código que controla el programa). Suele haber una tercera parte
icono/conector que son los medios utilizados para conectar un VI con otros VIs [79].
En el panel frontal, se encuentra todo tipos de controles o indicadores, donde cada uno de
estos elementos tiene asignado en el diagrama de bloques una terminal, es decir el usuario
podrá diseñar un proyecto en el panel frontal con controles e indicadores, donde estos
elementos serán las entradas y salidas que interactuarán con la terminal del VI. Podemos
observar en el diagrama de bloques, todos los valores de los controles e indicadores, como
van fluyendo entre ellos cuando se está ejecutando un programa VI [79].
Ilustración 109: Diagrama de Bloques-Array de 100
4. ORGANIZADORES GRÁFICOS DE RESUMEN

Ilustración 110.- Sistema digital

Ilustración 111.- Sistema Digital Combinacional
Ilustración 112.- Sistema digital secuencial

Ilustración 113.- Autómatas finitos
Ilustración 114.- Micro Dispositivo

Ilustración 115.- Sistema Digital Programables
Ilustración 116.- Proceso de Programación y Ejecución

Ilustración 117.- Sistemas Reconfigurables
2. Autómatas Finitos
Ilustración 118 Diseño de Autónomas Finitos
Ilustración 119 Proceso d Diseño

Ilustración 120 Tabla de Diseño (Mealy)
Ilustración 121 Tabla de Diseño (Moore)

Ilustración 122 Definición y Estructura de Arduino
Ilustración 123 Tipos de Arduino
Ilustración 124 Características principales de PIC

Tabla 1 Ventajas y desventajas de Microcontroladores
Ilustración 125 Especificaciones básicas del PIC
Ilustración 126 características de PIC C Compiler

5. Librerías, Fusibles e Interrupciones
Ilustración 127: Esquema-Librerías, Fusibles e Interrupciones
Ilustración 128: Esquema-Pic C Compiler

Ilustración 2.- Sensores
Ilustración 3.- Tipos de Sensores

Ilustración 4.- Actuadores
Ilustración 5.- Formas de Actuadores

7. Comunicaciones
Ilustración 20: Comunicaciónes.
Ilustración 21: Comunicación serial.

Ilustración 22: Comunicación SPI.
Ilustración 23: Comunicación I2C.

Ilustración 24: Radiofrecuencia.
Ilustración 25: Bluetooth.

Ilustración 26: Zigbee.
Ilustración 27: Modulo Xbee.

8. Comunicación inalámbrica WIFI
Ilustración 6 Mapa Conceptual Wifi
Ilustración 7 Comunicación Wifi con Arduino

Ilustración 8 Características del Módulo ESP8266
9. Métodos Y Metodología de Diseño de Vhdl
Ilustración 129. Evolución de las HDLs [4]

•VHDL fue diseñado con base a los principios de la programación estructurada.
¿Que es una Cada interfaz define un módulo de hardware mientras deja invisible sus detalles
internos. [1]
Estrutura en
VHDL?
•Permite la realización de diseños jerárquicos con el cual se defina la interfaz con el

entorno del sistema, conteniendo sus módulos interconectados y su diseño
contendrá sus terminales de entrada y salida. [2]
Que es una •Cada declaración se encontrará en la caja negra, donde estarán sus respectivas
Entidad terminales de la entidad. [2]
•Consiste en la declaración que se le asigne permitiendo la definición de la función

del circuito que se empleara. [3]
Que es una •La entidad tiene diferentes arquitecturas y es en la simulación donde se la
especifica la síntesis de la arquitectura concreta. [4]
Arquitectura
Ilustración 130. Estructura VHDL [10] [11] [12] [13]
Modelo Comportamental
• Un Modelo comportamental puede suministrar un pequeño parecido a la implementación
del sistema.
• El lenguaje VHDL permite escribir funciones complejas sin recurrir a su implantación física
con lo que se revela como una herramienta de gran rendimiento ya que proporciona una
potencia de diseño muy atractiva a un coste muy bajo.
Modelo Estructural
• La descripción estructural básicamente es crear la arquitectura en base a modelos lógicos ya
establecidos en el cual el usuario puede diseñar estructuras y guardarlas para después
volverlas a utilizar en diferentes trabajos.
• La descripción estructural es utilizada para la creación de la arquitectura de la entidad,
entidades descritas y compiladas previamente, de esta manera en VHDL podemos
aprovechar diseños ya realizados o realizar diseños sabiendo que se utilizaran en otros más
complicados
Ilustración 131. Modelo de Creación de VHDL [14] [15][16]

Ilustración 132. Metodología de Diseño [17]
Ilustración 133. Diseño Top-Down [27] [28]

Ilustración 134. Diseño Bottom-Up [28] [29]
10. Creación de Proyecto

Ilustración 135 Organizadores Gráficos de Resumen [Altamirano M.- Barreno J.- Cando E]
Ilustración 115 Organizadores Gráficos de Resumen [Jiménez G.- Rivera C.- Chuquitarco W.]
Ilustración 136:Definiciones de Código [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
Ilustración 137:Convertidor de código definición [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]

Ilustración 138: PORT MAP [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
Ilustración 139:Componentes e instanciación [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]

12. Sistemas Embebidos con dispositivos FPGA
No confundir el valor de un
objeto con un atributo de
un objeto.
Un objeto tiene un único valor y
Caracteristicas puede tener varios atributos
VHDL tiene atributos predefinidos y
Es una también permite la definición de
característica que nuevos atributos
denota funciones
o rangos Atributos sobre rangos de
asociados a un vectores
elemento de un Atributos sobre tipos de
Atributos modelo VHDL. Principales datos
atributos Atributos sobre señales
Atributo Event
Atributos
definidos Declaracion
por el Especificacion
usuario
Ilustración 140 Atributos Elaborado por: Balladares, Bayas, Fiallos, Palan.
Modelado de Sistemas Secuenciales
Poseen un circuito combinacional y un

almacenado de memoria
Modelado VHDL de
Descripción VHDL
El atributo EVENT la activación por
de lógica secuencial
flanco.
Usando macros
VHDL'93 rising
edge(señal)y falling
Se describe la Se considera una edge (señal)
señal de reloj, Se puede usar la
activación por sentencia WAIT
flanco de reloj. genera cambios de
"0" a "1" o UNTIL
viceversa.
Ilustración 141 Modelado de Sistemas Secuenciales Elaborado por: Balladares, Bayas, Fiallos, Palan
CRICUITOS
Registros de
SECUENCIALES Contadores
Desplazamiento
VHDL
Simplificacion de Diagrama de
Flip Flops
Circuitos Logicos Estados
Ilustración 142 Ejemplos de Sistemas Secuenciales en VHDL Elaborado por: Balladares, Bayas, Fiallos, Palan
Ilustración 1434 Sistemas FPGA Elaborado por: Muquinche, Ramos, Soto, Salazar
Ilustración 1445 Sistemas FPGA NI Elaborado por: Muquinche, Ramos, Soto, Salazar
5. EJERCICIOS RESUELTOS
Primer Parcial
Sin realización de ejercicios en la primera semana.
Ejercicios de clase 1
• Tema
Contador de ciclos
• Objetivos
- General
➢ Realizar un contador de que contabilice los ciclos ascendente y descendente de un
maquina secuencial.
- Específicos
maquina secuencial diseñado en Mealy.
maquina secuencial diseñado en Moore
• Materiales y Equipos
➢ Computadora
➢ Apuntes de clases
➢ Software Proteus
➢ Software BooleDeusto
• Desarrollo
Diseño basado en Mealy
➢ Diseño en Boole
➢ Simulación en Proteus
Diseño basado en Moore

• Resultados
El diseño realizado en base a un autómata de Mealy cuenta los ciclos de un contador

ascendente descendente MOD 4 no presenta inconvenientes ya que las máquinas tipo Mealy
dependen además del estado interno también de la transición por lo que su diseño es simple,
no obstante el diseño realizado en base al autómata de Moore si bien cuenta los ciclos
ascendente y descendente de una maquina secuencial esta no es un contador, en los dos casos
los conteos de cuantos ciclos han completado están representados con un contador MOD 4.
Ejercicios de clase 2
• Tema
Detector de código 01
• Objetivos
- General
➢ Diseñar un detector de código continuo y segmentado
- Específicos
➢ Diseñar un detector de código continuo y segmentado usando una máquina
secuencial tipo Mealy.
➢ Diseñar un detector de código continuo y segmentado usando una máquina
secuencial tipo Moore.
➢ Simular el detector de código.
➢ Computadora
• Desarrollo
Detector Continuo
Detector Segmentado
Detector Continuo
Detector Continuo
Detector Segmentado
➢ Simulación Proteus
Detector Segmentado
• Resultados
El diseño del detector realizado en Boole tanto el continuo como el segmentado no presentan
fallos, al ingresar la secuencia detecta los códigos de manera correcta en la simulación del
detector continúo realizado en Proteus se adiciono un led a la salida del circuito para saber
cuándo ha sido ingresado una secuencia correcta, para ingresar la secuencia se usó un
estimulador lógico.
Ejercicio 1
Tema
Detector de código 01 Mealy continuo con Flip-Flop J-K.
Objetivos
➢ General
Realizar un Detector de código 01 con el modelo de autómata finito Mealy continuo con Flip-
Flop J-K.
➢ Específicos
1. Establecer el diagrama de estados para el modelo Mealy continuo en el software Boole
Deusto.
2. Ejecutar la tabla transición de estados y salidas, y la tabla de simulación de secuencia.
3. Llevar a cabo la tabla de diseño para obtener las funciones de estados y salidas.
Descripción
Diseñar un Detector de código 01 Mealy continuo con Flip-Flop J-K, realizar el diseño,
diagrama y tablas respectivas utilizando el software Boole Duesto e implementarlo en
Proteus.
Listado de Materiales y Equipos
➢ Software de simulación Boole Duesto
➢ Software de simulación Proteus
➢ Lápiz
➢ Papel
➢ Borrador
Diagrama de estados
Ilustración21: Diagrama de estados
Tabla de Transición y Salida
Ilustración22: Tabla de Transición y Salida
Tabla de Simulación de Secuencia
Ilustración23: Tabla de Simulación de Secuencia
Tabla de Diseño
Ilustración24: Tabla de Diseño
Entradas y Salidas con Flip-Flop J-K

Ilustración25: Entradas y Salidas con Flip-Flop J-K
Simulación
Ilustración26: Simulación
Resultados
➢ Cada una de los autómatas finitos que se analizaron dan a conocer la forma diferente
en que se podría realizar un diagrama de estados sea usando la máquina de Mealy y
Moore para su implementación.
➢ Cada una de los diagramas aplicados fueron implementado en hojas para después
aplicar en un diagrama de estados en un software llamado Boole Deusto el cual
permitió la comprobación con lo que permitirá clarificar cada uno de las transiciones
y salidas que se dio en el diagrama.
➢ La transición que toma cada uno de los estados permitió la realización de la
simulación de secuencia y tabla de diseño, a su vez se puede implementar mediante
flip-flops que son más utilizados y representados en los mapas K.
Ejercicio 2
Tema
Detector de código 01 Moore Continuo con Flip-Flop J-K.
Objetivos
➢ General
Realizar un Detector de código 01 con el modelo de autómata finito Moore Continuo con
Flip-Flop J-K.
➢ Específicos
1. Establecer el diagrama de estados para el modelo Moore Continuo en el software Boole
Deusto.
Descripción
Diseñar un Detector de código 01 Moore Continuo con Flip-Flop J-K, realizar el diseño,
Proteus.
➢ Lápiz
➢ Papel
➢ Borrador
Diagrama de estados

Tabla de Diseño
Ilustración31: Entradas y Salidas con Flip-Flop J-K
Simulacion
Resultados
➢ Cada uno de los autómatas finitos que se analizaron dan a conocer la forma diferente
Moore para su implementacion.
➢ Cada uno de los diagramas aplicados fueron implementado en hojas para después
Ejercicio 3
Tema
Detector de código 01 Moore Continuo con Flip-Flop D.
Objetivos
➢ General
Realizar un Detector de código 01 con el modelo de autómata finito Moore Continuo con
Flip-Flop D.
➢ Específicos
1. Establecer el diagrama de estados para el modelo Moore Continuo en el software Boole
Deusto.
Descripción
Diseñar un Detector de código 01 Moore Continuo con Flip-Flop D, realizar el diseño,
Proteus.
➢ Lápiz
➢ Papel
➢ Borrador
Diagrama de estados
Tabla de Diseño
Entradas y Salidas con Flip-Flop D

Ilustración37: Entradas y Salidas con Flip-Flop D
Simulacion
Resultados
Ejercicio 4
Tema
Detector de código 01 Moore Segmentado con Flip-Flop D.
Objetivos
➢ General
Realizar un Detector de código 01 con el modelo de autómata finito Moore Segmentado con
Flip-Flop D.
➢ Específicos
1. Establecer el diagrama de estados para el modelo Moore Segmentado en el software Boole
Deusto.
Descripción
Diseñar un Detector de código 01 Moore Segmentado con Flip-Flop D, realizar el diseño,
Proteus.
➢ Lápiz
➢ Papel
➢ Borrador
Diagrama de estados
Tabla de Diseño
Simulacion
Ilustración44: simulación
Resultados
Ejercicio 5
Tema
Contador de códigos de 4 bits (1010) Mealy Continuo con Flip-Flop D.
Objetivos
➢ General
Realizar un Contador de códigos de 4 bits (1010) con el modelo de autómata finito Mealy
continuo con Flip-Flop D.
➢ Específicos
1. Establecer el diagrama de estados para el modelo Mealy continuo en el software Boole
Deusto.
Descripción
Diseñar un contador de códigos de 4 bits (1010) con el modelo de Mealy continuo, realizar el
diseño, diagrama y tablas respectivas utilizando el software Boole Duesto e implementarlo en
Proteus.
➢ Lápiz
➢ Papel
➢ Borrador
Diagrama de estados

Tabla de Diseño
DA=X DB=B
S1=B’*A*X S2=B+A’+X’
Simulacion
Ilustración50: simulación
Resultados
➢ Cada una de los autómatas finitos que se analizaron dan a conocer la forma diferente en que
se podría realizar un diagrama de estados sea usando la máquina de Mealy y Moore para su
implementacion.
➢ Cada una de los diagramas aplicados fueron implementado en hojas para después aplicar en
un diagrama de estados en un software llamado Boole Deusto el cual permitió la
comprobación con lo que permitirá clarificar cada uno de las transiciones y salidas que se dio
en el diagrama.
➢ La transición que toma cada uno de los estados permitió la realización de la simulación de
secuencia y tabla de diseño, a su vez se puede implementar mediante flip-flops que son más
utilizados y representados en los mapas K.
Ejercicio 6
Tema
Contador de códigos de 4 bits (1010) Mealy Segmentado con Flip-Flop D.
Objetivos
➢ General
Realizar un Contador de códigos de 4 bits (1010) con el modelo de autómata finito Mealy
Segmentado con Flip-Flop D.
➢ Específicos
1. Establecer el diagrama de estados para el modelo Mealy Segmentado en el software Boole
Deusto.
Descripción
Diseñar un contador de códigos de 4 bits (1010) con el modelo de Mealy Segmentado,
realizar el diseño, diagrama y tablas respectivas utilizando el software Boole Duesto e
implementarlo en Proteus.
➢ Lápiz
➢ Papel
➢ Borrador
Diagrama de estados
Tabla de Diseño
Simulacion
Resultados
Ejercicio 7
Tema
Contador de códigos de 4 bits (1010) Moore continuo con Flip-Flop D.
Objetivos
➢ General
Realizar un Contador de códigos de 4 bits (1010) con el modelo de autómata finito Moore
continuo con Flip-Flop D.
➢ Específicos
1. Establecer el diagrama de estados para el modelo Moore continuo en el software Boole
Deusto.
4. Simular el contador de códigos de 4 bits en el software Proteus.
Descripción
Diseñar un contador de códigos de 4 bits (1010) con el modelo de Moore continuo con Flip-
Flop D, realizar el diseño, diagrama y tablas respectivas utilizando el software Boole Duesto
e implementarlo en Proteus.
➢ Lápiz
➢ Papel
➢ Borrador
Diagrama de estados
Tabla de Transición y Salidas
Ilustración58: Tabla de Transición y Salidas
Tabla de Simulación y Secuencia
Sec. 1 0 1 1 0 1 0 0 1 0 1 0 1 0 0 1 1 0 1 0 0 1 0 1
Qn 0 1 2 3 1 2 3 4 0 1 2 3 4 3 4 0 1 1 2 3 4 0 1 2
Qn+1 1 2 3 1 2 3 4 0 1 2 3 4 3 4 0 1 1 2 3 4 0 1 2 3
Y1 1 1 1 1 1 1 1 0 1 1 1 1 0 1 0 1 1 1 1 1 0 1 1 1
Y2 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 0 0 0 0 0 1 0 0 0
Ilustración59: Tabla de Simulación y Secuencia
Tabla de Diseño
Simulación
Resultados
Ejercicio 8
Tema
Contador de códigos de 4 bits (1010) Moore continuo con Flip-Flop J-K.
Objetivos
➢ General
Realizar un Contador de códigos de 4 bits (1010) con el modelo de autómata finito Moore
continuo.
➢ Específicos
1. Establecer el diagrama de estados para el modelo Moore continuo en el software Boole
Deusto.
4. Simular el contador de códigos de 4 bits en el software Proteus.
Descripción
Diseñar un contador de códigos de 4 bits (1010) con el modelo de Moore continuo, realizar el
diseño, diagrama y tablas respectivas utilizando el software Boole Duesto e implementarlo en
Proteus.
➢ Lápiz
➢ Papel
➢ Borrador
Diagrama de estados
Tabla de transición de estados y salidas
Ilustración64: Tabla de transición de estados y salidas
Tabla de simulación de secuencia
Ilustración65: Tabla de simulación de secuencia

Tabla de diseño
Ilustración66: Tabla de diseño
Funciones de estados y salidas
Ilustración67: Funciones de estados y salidas

Simulación
Resultados
Ejercicio Resuelto
Tema
Aplicación de microcontroladores en PIC y ARDUINO que controle un motor dc.
Objetivos
General
Realizar una aplicación d microcontroladores en PIC y ARDUINO que controle un
motor dc.
Específicos
• Investigar sobre la estructura del ARDUINO y PIC C COMPILER.
• Establecer el código para el control de un motor dc en Proteus.
• Verificar el funcionamiento de la simulación con los dos software y Proteus.
Descripción
Desarrollar el control básico de un motor dc desde Arduino y Pic C Compiler en
simulación con Proteus que permita controlar el giro horario y antihorario del motor,
así como también el control del motor mediante un puente H.

• Software Arduino
• Software Pic C Compiler
• Software Proteus
• Motor dc
• Placa Arduino simulada
• Puente H - L293D
Diagramas y Esquemas
Ilustración 145Código de Programación de Arduino

Ilustración 146 Diagrama de Proteus con Ejecutable de Arduino
Ilustración 147Código de Programación en PIC
Ilustración 148Simulación de Proteus con Pic C Compiler

ARDUINO IDE PIC
int boton1=1; #include <16F887.h>
int boton2=2; #fuses xt, nowdt
int giroAH=4; #use delay (clock=4000000)
int giroH=5;
int estado; #define boton1 PIN_B0
int estado2; #define boton2 PIN_B1
int led1=12;
int led2=13; #use fast_io (B)
void setup() { #use fast_io (D)
// put your setup code here, to run once:
pinMode(led2,OUTPUT); void main (){
pinMode(led1,OUTPUT); set_tris_B (0b00000011);//lector de
pinMode(giroAH,OUTPUT); entradas
pinMode(giroH,OUTPUT); set_tris_D (0);//lector de salidas
pinMode(boton1,INPUT); while (true){
pinMode(boton2,INPUT); if(input(boton1)==1){
if(input(boton2)==1){
} output_high (pin_D0);//led1
output_low (pin_D1);//led2
void loop() { output_high (pin_D2);//giro horario
estado2 = digitalRead(boton2);//on off output_low (pin_D3);//giro antihorario
if(estado2==HIGH){ }
estado=digitalRead(boton1); if(input(boton2)==0){
if(estado==HIGH){ output_low (pin_D0);//led1
digitalWrite(led2,HIGH); //muestra del led output_high (pin_D1);//led2
digitalWrite(led1,LOW); output_low (pin_D2);//giro horario
digitalWrite(giroH, HIGH); output_high (pin_D3);//giro antihorario
digitalWrite(giroAH, LOW); }
} }else{
if(estado==LOW){ output_low (pin_D0);//led1
digitalWrite(led2,LOW); output_low (pin_D1);//led2
digitalWrite(led1,HIGH); output_low (pin_D2);//giro horario
digitalWrite(giroH, LOW); output_low (pin_D3);//giro anti horario
digitalWrite(giroAH, HIGH); }
} }
}else{ }
digitalWrite(giroH, LOW);
digitalWrite(giroAH, LOW);
digitalWrite(led2,LOW);
digitalWrite(led1,LOW);
}
}
• TEMA
Control Básico de Motor DC
• OBJETIVOS
- Objetivo General
Desarrollar un programa que permita controlar el giro de un motor DC.
- Objetivos Específicos
Realizar la programación para un microcontrolador ATMega y PIC
Simular y verificar el funcionamiento del sistema usando el software Proteus.
• MATERIALES Y EQUIPOS
- Software Arduino IDE
- Software PicC compiler
- Software Proteus
- Computadora
- Apuntes de clases
• DESCRIPCION
Realizar un programa que permita controlar el giro horario y antihorario de un motor
DC, mediante el uso de interruptores que cambien el sentido, y además un interruptor
de encendido y apagado del motor.
• DESARROLLO
➢ Para el microcontrolador ATMega (Arduino)
Código de Programación
1. const int pulsador1=2;// control giro

2. const int pulsador2=3;// control de encendido y apagado
3. const int giroA=4;//giro antihorario
4. const int giroH=5;//giro horario
5. const int motor=7;//control de motor
6. int estado;
7. int estado2;
8. void setup() {
9.
10. pinMode(giroA,OUTPUT);
11. pinMode(giroH,OUTPUT);
12. pinMode(motor,OUTPUT);
13. pinMode(pulsador1,INPUT);
14. pinMode(pulsador2,INPUT);
15.
16. digitalWrite(giroA,LOW);
17. digitalWrite(giroH,LOW);
18. digitalWrite(motor,LOW);
19. }
20.
21. void loop() {
22.
23. estado2=digitalRead(pulsador2);
24. if (estado2==HIGH){
25. digitalWrite(motor,HIGH);
26. }
27. if (estado2==LOW){
28. digitalWrite(motor,LOW);
29. }
30. estado=digitalRead(pulsador1);
31. if (estado==HIGH){
32. digitalWrite(giroH,HIGH);
33. digitalWrite(giroA,LOW);
34. }
35. if(estado==LOW){
36. digitalWrite(giroH,LOW);
37. digitalWrite(giroA,HIGH);
38. }
39. }
Explicación del programa
Primero declaramos las variables que utilizaremos para el problema, de igual manera
renombraremos los pines que utilizaremos de la placa, en el Void setup() configuraremos los
pines dependiendo de cómo vayan a trabajar ya sean entradas (Input) o salidas (Output), En el
Void Loop() Realizamos la programación principal del problema, en este caso se controlará el
giro mediante un pulsador el cual dependerá de estado en el q lea el microcontrolador si el
estado está en alto entonces el pin del motor pasara a alto también, de igual manera para
apagar el motor, siguiendo esta lógica con el pulsador el cual si se encuentra en estado alto
permitirá que la salida del giro horario se ponga en alto y la de salida antihorario pase a bajo,
lo que permitirá el giro en un sentido y así controlar el movimiento del motor.
Simulación en Proteus
Giro Horario
Ilustración 149:Giro Horario-Arduino
Giro Antihorario
Ilustración 150:Giro Antuhorario-Arduino
➢ Para el microcontrolador PIC C Compiler
40. #include <16f887.h> // PIC que se va a usar

41. #fuses hs, nowdt // Configuracion de fusibles, hs_relog
42. #use delay(clock=20M) // La señal de reloj si se usa uno bajo
43.
44.
45. //Definicion de Variables
46. //Interruptor encendido y apagado //
47. #define interruptor0 porta,1 //
48.
49. //Interruptor para cambiar el giro (Izquierda/Derecha) //
50. #define interruptor1 portA,2 //
51.
52. //Salidas
53. #define encendido portB,0 //
54. #define giro_0 portB, 1 //
55. #define giro_1 portB, 2 //
56.
57. //Informar al programa la dirección de los puertos
58. #byte portb=6
59. #byte porta=5
60. void main(){
61. set_tris_a(0b110); //0 SALIDA, 1 ENTRADA
62. set_tris_b(0b11111000);
63. while(true){
64. if(bit_test(interruptor0)){
65. bit_set(encendido);
66. if(bit_test(interruptor1)){ //GIRO A LA DERECHA
67. bit_clear(giro_0);
68. bit_set(giro_1);
69. }else{ //GIRO A LA IZQUIERDA
70. bit_set(giro_0);
72. }
73.
74. }else{
75. bit_clear(encendido);// ENCENDIDO/APAGADO
78. }
79. }
80. }
Explicación del programa
Primero declaramos las variables que utilizaremos para el problema, de igual manera
renombraremos los pines que utilizaremos de la placa y por su puesto los fusibles a utilizar.
Una vez adecuado correctamente lo necesario para iniciar con lo que viene siendo para la
programación puesto a esto iniciamos con la lógica que será mediando un Switch para lo que
viene siendo el encendido y apagado y de igual forma otro en donde se procede a realizar los
giros. Junto con esto un led indicara si el giro es horario o anti horario.
Simulación en PIC C Compiler

Giro Horario
Ilustración 151:Giro Horario-Pic C Compiler
Giro Antihorario
Ilustración 152:Giro Antihorario-Pic C Compiler
Resultados
Se desarrolló la respectiva programación para cada uno de los microcontroladores pedidos

(ATMega y Pic) cumpliendo las condiciones de operación descritas por el ejercicio, logrando
controlar el giro de un motor DC de igual manera su encendido y apagado, y comprobando su
funcionamiento en el software de simulación Proteus.

• Tema:
Control de un motor mediante un teclado matricial y visualización en LCD mediante

el uso de arduino y pic.
• Objetivos:
General
• Construir un control de un motor mediante un teclado matricial y
visualización en LCD mediante el uso de arduino y pic.
Específicos
• Definir parámetros para la programación tanto en la interfaz arduino
como en la de pic c compiler.
• Desarrollar la simulación en proteus y verificar resultados y realizarlo
en la plataforma tinkercad el circuito de arduino
Descripción
Realizar un ejercicio que defina el giro del motor en sentido horario y anti horario para
esto usaremos un teclado el cual nos ayudara en primera instancia a encender el
programa después de girar el motor tanto en sentido horario como anti horario y por
ultimo con otro botón que se apague completamente el sistema.
▪ Computador
▪ Software arduino
▪ Software pic c compiler
▪ Software proteus
PROGRAMACIÓN EN ARDUINO
Ilustración 6.- Programación en arduino

#include <LiquidCrystal_I2C.h>
PROGRAMACIÓN ARDUINO #include <Keypad.h>
char pulsacion; // almacena la tecla lcd.clear();
pulsada }
void menu_1(){
unsigned long tiempo1 = (millis()/1000);
int contador = 1; // cuenta el nivel del menu

en el que se esta
const byte ROWS = 4; //Cuatro Filas lcd.setCursor(0,0);
const byte COLS = 3; //Cuatro Columnas lcd.print(" APAGADO ");
char keys[ROWS][COLS] = { if(pulsacion == '1') contador=2;
{'1','2','3'}, }
{'4','5','6'}, void menu_2(){
{'7','8','9'}, lcd.setCursor(0,0);
{'*','0','#'} lcd.print(" ENCENDIDO ");
}; if(pulsacion == '4') contador=3;
byte rowPins[ROWS] = {9,8,7,6}; //Puntos if(pulsacion == '2') contador=4;
de conexion del teclado al arduino FILAS if(pulsacion == '3') contador=5;
byte colPins[COLS] = {4,3,2}; //Puntos de }
conexion del teclado al arduino void menu_3(){
COLUMNAS
Keypad Teclado1 = Keypad( lcd.setCursor(0,0);
makeKeymap(keys), rowPins, colPins, lcd.print(" APAGADO ");
ROWS, COLS ); //Configura el teclado lcd.clear();
LiquidCrystal_I2C lcd(0x20,16,2); digitalWrite(10,LOW);
void setup () { digitalWrite(11,LOW);
lcd.init(); digitalWrite(12,LOW);
lcd.backlight(); digitalWrite(13,LOW);
pinMode(10, OUTPUT); if(pulsacion == '1') contador=2;
pinMode(11, OUTPUT); lcd.clear();
pinMode(12, OUTPUT); }
pinMode(13, OUTPUT); void menu_4(){
intro_0(); // muestra el intro de lcd.setCursor(5,5);
bienvenida lcd.print(" HORARIO ");
} digitalWrite(10,HIGH);
void loop(){ digitalWrite(11,LOW);
pulsacion = Teclado1.getKey() ; // Lee la digitalWrite(12,HIGH);
tecla pulsada digitalWrite(13,LOW);
if (pulsacion != 0) { if(pulsacion == '4') contador=3;
} if(pulsacion == '3') contador=5;
if(contador == 1){ menu_1();} }
if(contador == 2){ menu_2();} void menu_5(){
if(contador == 3){ menu_3();} lcd.setCursor(5,5);
if(contador == 4){ menu_4();} lcd.print(" ANTIHORARIO ");
if(contador == 5){ menu_5();} digitalWrite(10,LOW);
} digitalWrite(11,HIGH);
void intro_0(){ digitalWrite(12,LOW);
lcd.clear(); // Borra el LCD digitalWrite(13,HIGH);
lcd.setCursor(0,0); if(pulsacion == '2') contador=4;
lcd.print(" APAGADO "); if(pulsacion == '4') contador=3;
delay(1000); // espera 4 segundos }
mostrando el intro
PROGRAMACIÓN EN PIC C COMPILER
Ilustración 7.- Programación en Pic
PROGRAMACIÓN PIC
#include if((k!=0)&&(k!='3')&&(k!='0')&&(k!='4')&&
"C:\Users\dell\Desktop\danny\Quinto (k!='5')&&(k!='6')&&(k!='7')&&(k!='8')&&(
Semestre\Sistemas k!='9')&&(k!='*')&&(k!='#')){ //Para anular l
Embebidos\Giro_motor_lcd\Pic\giro_motor_l if (k=='1'){
cd.h" output_high(PIN_A0);
#fuses XT,WDT, PUT, NOPROTECT output_low(PIN_A1);
#use delay (clock=4000000) output_high(PIN_A2);
//se declara para hacer entrada o output_low(PIN_A3);
salida printf(lcd_putc,"\fENCENDIDO \n
#use standard_io(a) Giro: H " );
#define use_portd_lcd true //Declaro puertos delay_ms(1000000);
d para lcd }
#define use_portb_kbd true //Declaro else{
puertos b para kbd output_low(PIN_A0);
output_high(PIN_A1);
#include <LCD.C> //Incluimos librerias output_low(PIN_A2);
#include <KBD.C> output_high(PIN_A3);
#include <stdio.h> printf(lcd_putc,"\fENCENDIDO \n
void main() Giro: A " );
{ delay_ms(1000);
char k; // Declaro caracter para la lectura del }}}}
teclado
lcd_init(); //Inicio
kbd_init();
port_b_pullups(TRUE); //Activo puertos
con resistencias para el teclado
lcd_putc("\f SISTEMA APAGADO \n ");
while (TRUE){
k=kbd_getc(); // Declaro la variable para
la lectura de teclado
AMBATO-ECUADOR
• Resultados
SIMULACIÓN EN PROTEUS EL PROGRAMA DE ARDUINO
1. En primer lugar hacemos las conexiones según la programación y cargamos el archivo .hex, a
continuación comenzamos la simulación y observamos que se encuentra apagado.
Ilustración 8.- Simulación en Proteus con arduino

2. Al presionar la tecla 1 el sistema se enciende
3
AMBATO-ECUADOR
3. Al presionar la tecla 2 gira el motor en sentido horario siempre y cuando este encendido el
sistema.

4. Al presionar la tecla 3 el motor girara en sentido antihorario.
4
AMBATO-ECUADOR
5. Con la tecla 5 el sistema se apagará
SIMULACIÓN EN PROTEUS DEL PROGRAMA PIC C COMPILER
1. Primero realizamos las conexiones según la programación y cargamos el archivo .hex en el pic y
lo simulamos.
Ilustración 13.- Simulación en Proteus con pic
5
AMBATO-ECUADOR
2. Como observamos se encuentra apagado el circuito.
Ilustración 14.- Simulación en Proteus con pic 3

3. Presionamos la tecla 1 y encendemos y la tecla 2 después y el motor girara en sentido horario
6
AMBATO-ECUADOR
4. Presionamos la tecla 3 y el motor girara en sentido antihorario

5. Y el sistema lo apagamos con la tecla 4
7
AMBATO-ECUADOR
7. Comunicaciones
Ejercicio 1
Tema
Entradas y Salidas Análogas
Objetivos
General
Analizar las señales PWM que controlan un motor en base a la lectura de un sensor de
temperatura.
Específicos
• Determinar la lectura de temperatura empleando un sensor LM35
• Definir un control incremental continuo de motor DC en base a la variación de la
temperatura
• Evaluar los rangos de temperatura en pantalla LCD de DC de PWM
• Demostrar el Modelado para Microcontrolador PIC y para la Tarjeta Arduino en Proteus.
Descripción
Mediante los conocimientos requeridos se desea diseñar un sistema digital que permita el control de
un motor DC mediante señales PWM en base a la lectura de un sensor de temperatura que contenga
los siguientes parámetros
Lectura de temperatura empleando un sensor LM35
Visualización en pantalla LCD de Vin, ADC y Temperatura
Control incremental continuo de motor DC en base a la variación de la temperatura de
acuerdo a los siguientes rangos: LimInf: 30ºC - 0% de DC de PWM - LimSum: 80ºC - 100%
de DC de PWM
Visualización en pantalla LCD de DC de PWM
• Placa arduino
• Microcontrolador PIC
• LCD 16x4
• Sensor LM35
ARDUINO:
#include <LiquidCrystal.h>; temp=(5.0 * temp * 100.0)/1024.0;
LiquidCrystal lcd(9, 8, 7, 13, 12, 11, if(temp>=30 && temp<=80){ //El
10); motor únicamente va a estar encendido
int m1=6; entre 0 y 20 ºC
float lm35=A0; pwm=map(temp,30,80,0,255);
float temp=0; analogWrite(m1,pwm);
int pwm; }else { analogWrite(m1,LOW);}
float lect=0; //MUESTRA DE TEMPERATURA
void setup() { EN LCD
pinMode(m1, OUTPUT); lcd.setCursor(0,0);
pinMode(lm35, INPUT); lcd.print("T:");
lcd.begin(16,2); lcd.print(temp);
Serial.begin(9600); lcd.print(" ADC:");
} void loop() { lcd.print(lect);
//VELOCIDAD DE ACUERDO A LA lcd.setCursor(0,1);
TERMPERATURA lcd.print("V=");
temp=analogRead(lm35); lcd.print(temp/100);
lect=analogRead(lm35);
8
AMBATO-ECUADOR
Resultados
Velocidad menor a 30:
Ilustración 28: Velocidad menor a 30
Velocidad mayor a 30
Ilustración 29: Velocidad mayor a 30
Pwm
Ilustración 30: PWM de la velocidad del motor
17
AMBATO-ECUADOR
PIC C COMPILER
#INCLUDE <16f887.H> WHILE(1)

#device adc=10 //trabajar a 10 { //Lectura ADC
bits en la conversion analogo set_adc_channel(0);
digital //Selecciono el canal 0 (RA0)
#USE DELAY(CLOCK=4000000) duty=read_adc();
#FUSES tem=(duty*500)/1024;
XT,NOPROTECT,NOWDT,NOBRO //Conversion de bits a
WNOUT,NOPUT,NOLVP temperatura 0.4882
#INCLUDE <LCD.C> volt1=tem/100;
float duty=0; //Variable lcd_gotoxy(1,1);
almacena ciclo de trabajo los bits //Ubiquese en la posicion 1,1
de 0-255 printf(lcd_putc, "T= %1.1f",tem);
float tem; //Almacena la //Muestra el valor numerico de la
temperatura conversionconversion
int Timer2, Poscaler; // lcd_gotoxy(10,1);
configuracion del timer 2 printf(lcd_putc, "V= %f",volt1);
float volt1; lcd_gotoxy(1,2);
#define s1 pin_A3 //salida uno printf(lcd_putc,
del driver "ADC:%1.1f",duty);
#define s2 pin_A4 // salida 2 del if(tem>=30 && tem<=80){
driver int32 duty0=map( tem, 30, 80, 0,
#use standard_io(A) 100);
///Para mapear los datos int32 final=map( duty0, 0, 100, 0,
double map(double value, float 1023);
x_min, float x_max, float y_min, int d=final/10;
float y_max); output_low(s2);
VOID MAIN(){ output_high(s1);
setup_adc_ports(sAN0); set_pwm1_duty(final);
//Pongo RA0 como analogo lcd_gotoxy(11,2);
setup_adc(adc_clock_internal);
//Selecciono reloj interno para printf(lcd_putc,"D:%1.1D",d);
conversion analogo digital }} }
set_tris_a(0b00000001); double map(double value, float
//Pongo el RA0 como entrada x_min, float x_max, float y_min,
Timer2=249; // es un timer de float y_max)
8 bits. El timer 2 tine un prescaler {
y un poscaler return (y_min + (((y_max -
Poscaler=1;//configuracion del y_min)/(x_max - x_min)) * (value
timer 2 el poscaler debe tener un - x_min)));
valor de 1 }
setup_timer_2(t2_div_by_4,Time
r2,Poscaler);
//t2_div_by_4=prescaler puede
ser valores 1,4,16, timer2,
poscaler
setup_ccp1(ccp_pwm); //
configuramos el pwm ponemos el
puerto a usar y el modo
LCD_INIT();//Inicializar el driver
del lcd
18
AMBATO-ECUADOR
Resultados
Temperatura menor a 30 grados, el duty cycle es de 0%
Ilustración 31: Temperatura menor a 30°C
Temperatura mayor a 30 grados, el duty cycle va aumentando en un incremento continuo de

2%
Ilustración 32: Temperatura mayor a 30°C
Temperatura mayor a 80 el duty cycle es de 100%
19
AMBATO-ECUADOR
Ilustración 33: Temperatura mayor a 80°C
Ejercicio 2
Tema
Comunicación Inalámbrica
Objetivos
• General
➢ Desarrollar una comunicación inalámbrica mediante módulos bluetooth para el
control de señales PWM.
• Específicos
➢ Realizar el enlace mediante bluetooth de dos microcontroladores tanto para PIC y
Atmega
➢ Simular en Proteus para poder verificar los resultados obtenidos
Descripción
Diseñar el sistema digital que permita el control de un motor DC mediante señales PWM en
base a la lectura de un sensor de temperatura empleando 2 Microcontroladores conectados
inalámbricamente mediante Bluetooth:
Las condiciones de diseño son:
• Microcontrolador 1: Lectura de temperatura empleando un sensor LM35
• Visualización en pantalla LCD de Vin, ADC y Temperatura
• Microcontrolador 2: Control incremental continuo de motor DC en base a la variación de la
temperatura de acuerdo a los siguientes rangos: LimInf: 30ºC - 0% de DC de PWM -
LimSum: 80ºC - 100% de DC de PWM
• Visualización en pantalla LCD de DC de PWM
La simulación debe contener
• Modelado para Microcontrolador PIC (Proteus)
• Modelado para Tarjeta Arduino (Proteus)
• Software de simulación Proteus
• Software de programación PIC C COMPILER
• Arduino IDE
• LM35
• PIC 16F887
• Placa Arduino
• Driver l293
20
AMBATO-ECUADOR
• Modulo Bluetooth HC05

• Pantallas LCD 16x2
ARDUINO:
• Tansmisor: } void loop() {

#include <LiquidCrystal.h>; if(Serial.available()){
LiquidCrystal lcd(9, 8, 7, 13, 12, 11, 10); temp=Serial.read();
int lm35=A0; //pin del lm35 val=Serial.read();
int temp=0; //almacena los datos lcd.setCursor(0,0);
int c; // almacena los datos lcd.print("PWM:"
float lect=0; if(temp>=30 && temp<=80){ //El motor
double d=0; únicamente va a estar encendido entre 0 y 20
double val=0; ºC
void setup() { pwm=map(temp,30,80,0,255);
pinMode(lm35, INPUT); analogWrite(m1,pwm);
lcd.begin(16,2); lcd.setCursor(4,0);
Serial.begin(9600); lcd.print( pwm );
} void loop() { }else {
temp=analogRead(lm35); //lee los datos analogWrite(m1,pwm);
lect=analogRead(lm35); }}
c=(5.0 * temp * 100.0)/1024.0; //convierte
los bits a temperatura
d=(5.0 * temp * 100.0)/1024.0;
val=d/100;
//MUESTRA EN LCD
lcd.setCursor(0,0); //columna fila
lcd.print("T:");
lcd.print(c);
lcd.print(" ADC:");
lcd.print(lect);
lcd.setCursor(0,1);
lcd.print("V:");
lcd.print(val);
Serial.write(c);
}
• Receptor:
#include <LiquidCrystal.h>;
LiquidCrystal lcd(9, 8, 7, 13, 12, 11, 10);
int m1=6; //salida del motor dc
int pwm; //para el duty cicle
int temp;
int val=0;
void setup() {
pinMode(m1, OUTPUT);
lcd.begin(16,2);
Serial.begin(9600);
lcd.setCursor(0,0); //columna fila
21
AMBATO-ECUADOR
Resultados
Envío de datos por bluetooth
Ilustración 34: Envío de datos por bluetooth
PIC C COMPILER
Programa del Emisor //Selecciono el canal 0 (RA0)

duty=read_adc();
#INCLUDE <16f887.H> tem=(duty*500)/1024;//Conversion de
#device adc=10 //trabajar a 10 bits bits a temperatura 0.4882
#USE DELAY(CLOCK=4000000) volt1=tem/100;
#use rs232(baud=9600,xmit=pin_c6, lcd_gotoxy(1,1); //Ubiquese en la
rcv=pin_c7, parity=N, bits=8) posicion 1,1
#FUSES//XT,NOPROTECT,NOWDT printf(lcd_putc, "T= %1.1f",tem);
,NOBROWNOUT,NOPUT,NOLVP //Muestra el valor numerico de la
#INCLUDE <LCD.C> conversion
int duty=0; //Variable almacena ciclo lcd_gotoxy(10,1);
de trabajo los bits de 0-255 printf(lcd_putc, "V= %f",volt1);
float tem; //Almacena la temperatura lcd_gotoxy(1,2);
int Timer2, Poscaler; // configuracion printf(lcd_putc, "ADC:%1.1D",duty);
del timer 2 putc(duty);} }
float volt1;
VOID MAIN(){ Programa del Receptor
setup_adc_ports(sAN0); //Pongo
RA0 como analogo #INCLUDE <16f887.H>
setup_adc(adc_clock_internal); #USE DELAY(CLOCK=4000000)
//Selecciono reloj interno para #use rs232(baud=9600,xmit=pin_c6,
conversion analogo digital rcv=pin_c7, parity=N, bits=8)
set_tris_a(0b00000001); #FUSES
//Pongo el RA0 como entrada XT,NOPROTECT,NOWDT,NOBRO
LCD_INIT(); //Inicializar el WNOUT,NOPUT,NOLVP
driver del lcd #INCLUDE <LCD.C>
WHILE(1) int duty;
{//Lectura ADC float tem;
set_adc_channel(0); float volt1;
21
AMBATO-ECUADOR
int Timer2, Poscaler; // configuracion

del timer 2
#define s1 pin_A3 //salida uno del
driver
#define s2 pin_A4 // salida 2 del
driver
#use standard_io(A)
#int_RDA
RDA_isr()
{ duty=getc();}
///Para mapear los datos
double map(double value, float x_min,
float x_max, float y_min, float
y_max);
void main()
{Timer2=249; // es un timer de 8
bits. El timer 2 tine un prescaler y un
poscaler Poscaler=1; //en la
configuracion del timer 2 el poscaler
debe tener un valor de 1
setup_timer_2(t2_div_by_4,Timer2,Po
scaler); //t2_div_by_4=prescaler puede
ser valores 1,4,16, timer2, poscaler
configuramos el pwm ponemos el
puerto a usar y el modo
lcd_init();
enable_interrupts(INT_RDA);
enable_interrupts(GLOBAL);
while(1) { tem=(duty*500)/1024;
//Conversion de bits a temperatura
0.4882
volt1=tem/100;
lcd_gotoxy(1,1); //Ubiquese en la
posicion 1,1
printf(lcd_putc, "T= %1.1f",tem);
//Muestra el valor numerico de la
conversionconversion
lcd_gotoxy(10,1);
printf(lcd_putc, "V= %f",volt1);
lcd_gotoxy(1,2);
22
AMBATO-ECUADOR
RESULTADOS
Para temperaturas menores a 30 el duty cycle es de 0%
Ilustración 35: Duty Cycle de 0%
Para temperaturas mayores a 30 el duty cycle varia
Ilustración 36: Variación del duty cycle
Para cualquier valor de temperatura entre 30 y 80 el duty varia en un 2%
23
AMBATO-ECUADOR
Ilustración 37: El duty varia en un 2%
8. Comunicación inalámbrica Wifi

Desarrollo del Proyecto Final
ARDUINO
Para empezar con la etapa de desarrollo del contenido practico en Proteus, se
considera un nodo de trabajo que permita conectar los dos sensores el LM35 y el
ultrasónico a la placa Arduino 1 Emisor conectado con un módulo Bluetooth y el
teclado matricial, junto con la pantalla LCD, para el segundo nodo de trabajo se necesita
el módulo Bluetooth, la pantalla LCD, conexión de los dos motores con la placa
Arduino 2 Receptor.
Dentro de estos nodos la función principal es controlar los motores a partir de los
sensores, condicionando el control incremental continuo y el control incremental
discreto en base a los sensores para temperatura y para distancia. Es importante que se
visualice la información de los sensores como actuadores dentro de cada uno de los
LCD, para esto se utiliza una única forma de control que se manipula dentro de la
programación de Arduino permitiendo la transmisión y recepción de los datos.
Arduino Emisor
24
AMBATO-ECUADOR
Ilustración 153 Arduino IDE (Emisor).
Arduino Receptor
Ilustración 154 Arduino IDE (Receptor).
Control Menú (Arduino)

TECLA OPCION
1 Temperatura (lm35) – Motor DC
2 Distancia (ultrasónico)- Servo Motor
A Regreso Menú
25
AMBATO-ECUADOR
Ilustración 155 Menú para control del sistema.
• PARA LA OPCIÓN 1 DEL TECLADO

Temperatura (lm35) - Motor DC
o Cuando la temperatura es menor a 50 grados/ dutty=0%.
Ilustración 156 Temperatura menor a 50 / Dutty 0%.
26
AMBATO-ECUADOR
o Cuando la temperatura varía entre 50 y 100 grados/dutty=incremento del 2%.
Ilustración 157 Temperatura 50-100 / Dutty incremento.
27
AMBATO-ECUADOR
o Cuando la temperatura es mayor a 100 grados/dutty=100%.
Ilustración 159 Temperatura mayor a 100 / Dutty 100%.
• PARA LA OPCIÓN 2 DEL TECLADO
Distancia (ultrasónico)- Servo Motor

o Distancias entre 0 - 10cm/ángulo 0°.
28
AMBATO-ECUADOR
Ilustración 160 Distancias entre 0 - 10cm/ángulo 0°.
o Distancias entre 10 - 20cm /ángulo 30°.
29
AMBATO-ECUADOR
30
AMBATO-ECUADOR
31
AMBATO-ECUADOR
o Distancias entre 60 - 70cm/ángulo 180.
PIC C COMPILER
Del mismo modo que en Arduino con cada especificación y condición se colocan
los elementos y se genera un control en este caso utilizando PIC 16F887, conectando
los sensores y actuadores en dos nodos de trabajo 3y observando los resultados en los
LCD como se va a observar a continuación en las ilustraciones de simulación.
32
AMBATO-ECUADOR
Control Menú (PIC)

TECLA OPCION
1 Temperatura (lm35) – Motor DC
2 Distancia (ultrasónico)- Servo Motor
A Regreso Menú
Tabla 2 Control del Menú. Elaborado por: Balladares, Gutiérrez, Pallo.
EMISOR
Ilustración 167 Pic C Compiler (Emisor).
RECEPTOR
Ilustración 168 Pic C Compiler (Receptor).
33
AMBATO-ECUADOR
Ilustración 169Menú para control del sistema.
• Para la opción 1
Temperatura (lm35) - Motor DC
o Cuando la temperatura es menor a 50 grados/ dutty=0%.
Ilustración 170 Temperatura menor a 50 / Dutty 0%.
34
AMBATO-ECUADOR
o Cuando la temperatura varía entre 50 y 100 grados/dutty=incrementando.
35
AMBATO-ECUADOR
o Cuando la temperatura es mayor a 100 grados/dutty=100%.
Ilustración 173 Temperatura mayor a 100 / Dutty 100%.
• Para la opción 2
Distancia (ultrasónico)- Servo Motor
36
AMBATO-ECUADOR
Ilustración 174Distancias entre 0 - 10cm/ángulo 0°. Elaborado por: Balladares, Gutiérrez, Pallo.
o Distancias entre 10 - 20cm /ángulo 30°.
37
AMBATO-ECUADOR
38
AMBATO-ECUADOR
39
AMBATO-ECUADOR
Ilustración 179 Distancias entre 50 - 60cm/ángulo 150°. Elaborado por: Balladares, Gutiérrez, Pallo.
CODIGO ARDUINO
EMISOR RECEPTOR
40
AMBATO-ECUADOR
////////**ULTRASONICO**////// #include <Servo.h> // libreria de servo

#include <HCSR04.h> motor
///////**LCD**//////// #include <LiquidCrystal.h>
#include <LiquidCrystal.h> Servo servoMotor;
const int rs = 8, en = 9, d4 = 10, d5 = 11, const int rs = 8, en = 9, d4 = 10, d5 = 11,
d6 = 12, d7 = 13; d6 = 12, d7 = 13 ;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7); LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
//// **TECLADO**//////// // ordena el array para la recepcion de
#include <Keypad.h> datos por posicion
char key = " "; #define DEBUG_ARRAY(a) {for (int
const byte FILAS = 4; index = 0; index < sizeof(a) /
const byte COLUM = 4; sizeof(a[0]); index++)
//Definimos los simbolos del teclado {Serial.print(a[index]); Serial.print('\t');}
matricial Serial.println();};
char teclado [FILAS][COLUM] = { const char separator = ','; //Separador
{'1', '2', '3', 'A'}, const int dataLength = 6; //Distancia de
{'4', '5', '6', 'B'}, la cadena de datos
{'7', '8', '9', 'C'}, float data[dataLength]; //Cadena de
{'*', '0', '#', 'D'} datos
}; //Variables para la recepcion de datos y
//Definimos los pines que va a utilizar control de actuadores
byte PINFILAS[FILAS] = {31, 33, 35, float a = 4, b = 3, c = 2;
37}; float pwm = 5;
byte PINCOLUM[COLUM] = {29, 27, int m1 = 4;
25, 23}; int m2 = 3;
//Mapeo del teclado float temp2 = 0;
Keypad tecla = float ma1 = 0;
Keypad(makeKeymap(teclado), int dutty1 = 0;
PINFILAS, PINCOLUM, FILAS, int ma = 0;
COLUM); void setup()
//////declaracion pines ultrasonico//// {
UltraSonicDistanceSensor // Declaracion de los pines de salida
distanceSensor(2, 3); para el control del motor y del servo
//////variables recepcion Serial//// pinMode(pwm, OUTPUT);
#define DEBUG_ARRAY(a) {for (int pinMode(m1, OUTPUT);
index = 0; index < sizeof(a) / pinMode(m2, OUTPUT);
sizeof(a[0]); index++) servoMotor.attach(6);
{Serial.print(a[index]); Serial.print('\t');} lcd.begin(16, 2);
Serial.println();}; Serial.begin(9600);
String str = ""; lcd.setCursor(0, 0);
const char separator = ','; lcd.print(" VLSI "); //Prendido de
const int dataLength = 3; pantalla
float datoR[dataLength]; lcd.setCursor(0, 1);
int dutty = 0; lcd.print(" PROYECTO ");
int dutty1 = 0; delay (1000);
41
AMBATO-ECUADOR
int ma = 0; lcd.clear();
int ang = 0; }
void setup() { void loop() {
// put your setup code here, to run once: if (Serial.available()) // ABRE EL
Serial.begin(9600); BUCLE DE RECEPCION DE DATOS
lcd.begin(16, 2); {
lcd.setCursor(0, 0); String str =
lcd.print("VLSI"); //Prendido de Serial.readStringUntil('\n'); //
pantalla Almacena en una variable string la
lcd.setCursor(0, 1); lectura del dato
lcd.print(" PROYECTO "); for (int i = 0; i < dataLength ; i++)
delay (1000); // Creamos un ciclo For para incrementar
lcd.clear(); ka dadena de datos
} {
void loop() { int index = str.indexOf(separator);
// put your main code here, to run // Leemos los datos de la variable String e
repeatedly: identificamos el separador definido
data[i] = str.substring(0,
principal(); index).toFloat(); // Posicionamos y
} transformamos a flotantes los datos
void principal() { receptados
inicio: str = str.substring(index + 1);
lcd.setCursor(0, 0); // Desplazamiento de cada dato en el
lcd.print("1=>TEMP-M_DC ciclo for
");//S1=DISTANCIA, }
S2=TEMPERATURA, }
S3=LUMINISIDAD // Separamos los datos del Array de
lcd.setCursor(0, 1); Numeros acorde a los datos enviados
lcd.print("2=>DIST-SERVO "); float dist = data[0];
//S4=GAS, S5=SONIDO float ang = data[1];
Serial.print(0); float temp1 = data[2];
Serial.print(','); float dutty = data[3];
Serial.print(0); float menu = data[5];
Serial.print(',');
Serial.print(0); //Acorde a los datos receptados se ingresa
Serial.print(','); a los metodos
Serial.print(0); if (menu != 0) {
Serial.print(','); // Generamos el metodo menu y
Serial.print(0); declaramos a los actuadores en 0
Serial.print(','); lcd.setCursor(0, 0);
Serial.println(5); lcd.print("1=>TEMP-MTR_DC ");
lcd.setCursor(0, 1);
while (1) { lcd.print("2=>DIST-SERVO ");
key = tecla.getKey(); servoMotor.write(0);
if (key != 0) { analogWrite(pwm, 0);
42
AMBATO-ECUADOR
if (key == '1') { }
lcd.clear(); // Receptamos los datos de distancia para
temperatura(); ingresar a este metodo
if (dist != 0) {
} //Creamos los condicionales para el
if (key == '2') { control del servomotor
lcd.clear(); if (dist < 10) {
distancia(); // Normalizamos las variables para
} imprimir en el LCD
if (key == 'A') { float tiempo = (2 * dist) / 343; //
lcd.clear(); Formula para determinar el tiempo
goto inicio; int ang1 = 0; // Asiganacion
} del angulo bajo el rango de trabajo
} servoMotor.write(0);
} lcd.setCursor(0, 0);
} lcd.print("Servo ");
//<<<<<<<<<Metodos lcd.print("D=");
Sensores>>>>>>>>// lcd.print(dist);
//DISTANCIA lcd.print("cm ");
void distancia() { lcd.print("Ang=");
while (1) { lcd.print(ang1);
if (Serial.available()) { lcd.print("T=");
str = Serial.readStringUntil('\n'); lcd.print(tiempo);
for (int i = 0; i < dataLength ; i++) { lcd.print("s ");
int index = str.indexOf(separator); }
datoR[i] = str.substring(0, if (dist >= 10 && dist <= 60) {
index).toFloat(); float tiempo = (2 * dist) / 343;
str = str.substring(index + 1); int ang1 = ang;
} servoMotor.write(ang1);
} lcd.setCursor(0, 0);
float distance = lcd.print("Servo ");
distanceSensor.measureDistanceCm(); lcd.print("D=");
if (distance < 10) { lcd.print(dist);
ang = 0; lcd.print("cm ");
lcd.setCursor(0, 0); lcd.setCursor(0, 1);
lcd.print("Servo "); lcd.print("Ang=");
lcd.print("Ang= "); lcd.print(ang1);
lcd.print(0); lcd.print("T=");
lcd.print(" "); lcd.print(tiempo);
lcd.setCursor(0, 1); lcd.print("s ");
lcd.print("D= "); }
lcd.print(distance); if (dist > 60) {
lcd.print(" cm "); float tiempo = (2 * dist) / 343;
} int ang1 = ang;
43
AMBATO-ECUADOR
if (distance >= 10 || distance < 60) { servoMotor.write(180);

ma = map(distance, 0, 60, 0, 6); lcd.setCursor(0, 0);
ang = ma * 30; lcd.print("Servo ");
lcd.setCursor(0, 0); lcd.print("D=");
lcd.print("Servo "); lcd.print(dist);
lcd.print("Ang= "); lcd.print("cm ");
lcd.print(ang); lcd.setCursor(0, 1);
lcd.setCursor(0, 1); lcd.print("Ang=");
lcd.print("D= "); lcd.print(ang1);
lcd.print(distance); lcd.print("T=");
lcd.print(" cm "); lcd.print(tiempo);
} lcd.print("s ");
if (distance >= 60) { }
ang = 180; }
// TEMPERATURA
lcd.setCursor(0, 0); if (temp1 != 0) {
lcd.print("Servo "); // Condiciones de activacion para el
lcd.print("Ang= "); funcionamiento del Motor DC
lcd.print(180); if (temp1 < 50) {
ma = 0;
lcd.setCursor(0, 1); ma1 = temp1 / 100;
lcd.print("D= "); dutty1 = 0;
lcd.print(distance); analogWrite(pwm, ma); //Control
lcd.print(" cm "); de pwm
} digitalWrite(m1, LOW); // control
Serial.print(distance); de enccendido
Serial.print(','); digitalWrite(m2, HIGH);
Serial.print(ang); }
Serial.print(','); if (temp1 >= 50 && temp1 < 100) {
Serial.print(0); dutty1 = dutty;
Serial.print(','); temp2 = constrain(temp1, 50, 100);
Serial.print(0); float ma = map(temp2, 50, 100, 0,
Serial.print(','); 255);
Serial.print(0); ma1 = temp1 / 100;
Serial.print(','); analogWrite(pwm, ma);
Serial.println(0); digitalWrite(m1, LOW);
delay(200); digitalWrite(m2, HIGH);
//salir }
key = tecla.getKey(); if (temp1 >= 100) {
if (key == 'A') { ma = 255;
lcd.clear(); ma1 = temp1 / 100;
principal(); dutty1 = 100;
} analogWrite(pwm, ma);
} digitalWrite(m1, LOW);
} digitalWrite(m2, HIGH);
44
AMBATO-ECUADOR
}
//S2 TEMPERATURA lcd.setCursor(0, 0);
void temperatura() { lcd.print("M_DC");
while (1) { lcd.setCursor(4, 0);
if (Serial.available()) { lcd.print(" T= ");
str = Serial.readStringUntil('\n'); lcd.print(temp1);
for (int i = 0; i < dataLength ; i++) { lcd.print(" oC");
int index = str.indexOf(separator); lcd.setCursor(0, 1);
datoR[i] = str.substring(0, lcd.print("V=");
index).toFloat(); lcd.print(ma1);
str = str.substring(index + 1); lcd.print("V ");
} lcd.print("Dt= ");
} lcd.print(dutty1);
float dato = analogRead(A0); lcd.print("% ");
float volt = (5.0 * dato) / 1023 ; }
float temp1 = volt * 100; }
//float volt2 = map(temp1, 50.0, 100.0,
0, 5);
if (temp1 < 50) {
dutty = 0;
}
if (temp1 >= 50 || temp1 < 100) {
dutty1 =constrain(temp1,50,100);
dutty = map(dutty1, 50, 100, 0, 100);
}
if (temp1 >= 100) {
dutty = 100;
}
lcd.print("M_DC");
lcd.print(" T= ");
lcd.print(temp1);
lcd.print(" oC");
//lcd.print("V=");
//lcd.print(volt2);
//lcd.print("V ");
lcd.print("Dt= ");
lcd.print(dutty);
lcd.print("% ");
Serial.print(0);
Serial.print(',');
Serial.print(0);
Serial.print(',');
Serial.print(temp1);
45
AMBATO-ECUADOR
Serial.print(',');
Serial.print(dutty);
Serial.print(',');
Serial.print(0);
Serial.print(',');
Serial.println(0);
delay(200);
//salir
key = tecla.getKey();
if (key == 'A') {
lcd.clear();
principal();
}
}
}
CODIGO EN PIC C COMPILER
EMISOR RECEPTOR
#include <16f887.h> #include <16f887.h>
#device adc=10 #device adc=10
#FUSES #FUSES
INTRC,NOWDT,NOPUT,MCLR,NOPR INTRC,NOWDT,NOPUT,MCLR,NOPR
OTECT,NOCPD,NOBROWNOUT,NOI OTECT,NOCPD,NOBROWNOUT,NOIE
ESO,NOFCMEN,NOLVP SO,NOFCMEN,NOLVP
#use delay(clock=8M) #use delay(clock=8M)
#use RS232 (BAUD=9600, BITS=8, #use RS232 (BAUD=9600, BITS=8,
PARITY=N, XMIT=PIN_C6, PARITY=N, XMIT=PIN_C6,
RCV=PIN_C7) RCV=PIN_C7)
#define LCD_DB4 PIN_D4 #define LCD_DB4 PIN_D4
#define LCD_RS PIN_D2 #define LCD_RS PIN_D2
#define LCD_E PIN_D3 #define LCD_E PIN_D3
#include <teclado.c> #include <lcd1.c>
#include <lcd1.c> #include <stdlib.h>
#include <stdlib.h> #use standard_io(e)
int dc; #use standard_io(a)
int pwm,pwm1; #use fast_io(b)
float distancia, tiempo;
int dc;
char tring[5]; int pwm,pwm1;
int i=0; char cadena[6]; //Guardará el
string recibido
#define trig pin_A1 int i=0,o=0; //Número de caracteres del
#define echo pin_A2 string
#USE standard_io(a) float
46
AMBATO-ECUADOR
h;/********************************
INT valor1; **********************************
************/
#INT_RDA
RDA_isr() /************************FUNCIÓN
{ PRINCIPAL***********************
valor1=getc(); **********/
} //Interrupción por recepción
de datos
void main() #int_RDA
{ RDA_isr()
INT x; {
CHAR k; leer:
enable_interrupts(INT_RDA); cadena[i]=getc();//Recepción del string
lcd_init(); if(cadena[i]=='B')//todos los caracteres
kbd_init(); recibidos
printf(lcd_putc,"1=>Temp M.DC"); {o=1;i=0;goto leer;
lcd_gotoxy(1,2); set_pwm2_duty(0);}
printf(lcd_putc,"2=dis-servo"); if(cadena[i]=='A')//todos los caracteres
recibidos
setup_adc(ADC_CLOCK_INTERNAL); {o=2;i=0;goto leer;
set_pwm1_duty(0);}
setup_timer_1(T1_INTERNAL|T1_DIV_ if(cadena[i]=='C')//todos los caracteres
BY_1); recibidos
{o=3;i=0;goto leer;
FLOAT sensor=0; set_pwm1_duty(0);
WHILE(1) set_pwm2_duty(0);}
{
k=kbd_getc(); if(o==1)
{
IF(k!=0) ++i;
{ if(i==6)//todos los caracteres recibidos
x=k; {
if (k=='2') //recibe el siguiente caracter
{ putc('A');} h=atof(cadena);//paso del string a su
if (k=='1') valor float
{ putc('B');} lcd_gotoxy(1,1);
if (k=='A') printf(lcd_putc,"temp= %f ",h);
{ putc('C');}
} pwm=(5.1)*h-255;
pwm1=pwm;
IF(x=='1') dc=(pwm*100.00)/255.00;
{ if(h<50)
set_adc_channel(0);//lectura Vout {
del LM35 en PIN A0 set_pwm1_duty(0);
delay_us(1); lcd_gotoxy(1,2);
printf(lcd_putc," DC 0 ");
47
AMBATO-ECUADOR
sensor=read_adc();//sensor=variable que }
contendra Vout del LM35 if(h>=50&&h<=100)
sensor=(sensor*4.88)/10; {
set_pwm1_duty(pwm1);
lcd_gotoxy(1,1);printf(LCD_PUTC,"TE lcd_gotoxy(1,2);
MP%f C ",sensor); printf(lcd_putc," DC %i ",dc);
}
sprintf(tring,"%01.2f",sensor); if(h>100)
{
pwm=(5.1)*sensor-255; set_pwm1_duty(255);
pwm1=pwm; lcd_gotoxy(1,2);
dc=(pwm*100.00)/255.00; printf(lcd_putc," DC 100 ");
if(sensor<50) }
{ i=0;
lcd_gotoxy(1,2); }
printf(lcd_putc," DC 0 "); }
} if(o==2)
if(sensor>=50&&sensor<=100) {
{ ++i;
if(i==6)//todos los caracteres recibidos
lcd_gotoxy(1,2); {
printf(lcd_putc," DC %i //recibe el siguiente caracter
",dc); h=atof(cadena);//paso del string a su
} valor float
if(sensor>100) lcd_gotoxy(1,1);
{ printf(lcd_putc,"dist= %f ",h);
lcd_gotoxy(1,2); lcd_gotoxy(1,2);
printf(lcd_putc," DC 100 "); if(h<30)
} {
// puts(tring); set_pwm2_duty(0);
for (i=0;i<=5;i++) lcd_gotoxy(1,2);
{ printf(lcd_putc,"ang: 0 ");
putc(tring[i]); }
} if(h>=10&&h<20)
} {
IF(x=='2') set_pwm2_duty(42);
{ lcd_gotoxy(1,2);
output_high(trig); printf(lcd_putc,"ang: 30 ");
delay_us(10); }
output_low(trig); if(h>=20&&h<30)
{
WHILE(!input(echo)) set_pwm2_duty(85);
{} lcd_gotoxy(1,2);
set_timer1(0); printf(lcd_putc,"ang: 60 ");
}
WHILE(input(echo)) if(h>=30&&h<40)
{} {
tiempo=get_timer1(); set_pwm2_duty(127);
48
AMBATO-ECUADOR
distancia=(tiempo/2)/(29.15); lcd_gotoxy(1,2);
lcd_gotoxy(1,1); printf(lcd_putc,"ang: 90 ");
printf(lcd_putc,"Dis=%f cm }
",distancia); if(h>=40&&h<50)
sprintf(tring,"%01.2f",distancia); {
//puts(tring); if(h<30) set_pwm2_duty(170);
{ lcd_gotoxy(1,2);
lcd_gotoxy(1,2); printf(lcd_putc,"ang: 120 ");
printf(lcd_putc,"ang: 0 "); }
} if(h>=50&&h<60)
if(distancia>=10&&distancia<20) {
{ set_pwm2_duty(212);
lcd_gotoxy(1,2); lcd_gotoxy(1,2);
printf(lcd_putc,"ang: 30 "); printf(lcd_putc,"ang: 150 ");
} }
if(distancia>=20&&distancia<30)
{ if(h>60)
lcd_gotoxy(1,2); {
printf(lcd_putc,"ang: 60 "); set_pwm2_duty(255);
} lcd_gotoxy(1,2);
if(distancia>=30&&distancia<40) printf(lcd_putc,"ang: 180 ");
{ }
lcd_gotoxy(1,2); i=0;
} }
if(distancia>=40&&distancia<50) if(o==3)
{ {
lcd_gotoxy(1,2); set_pwm1_duty(0);
printf(lcd_putc,"ang: 120 "); set_pwm2_duty(0);
} printf(lcd_putc,"1=>Temp M.DC ");
if(distancia>=50&&distancia<60) lcd_gotoxy(1,2);
{ printf(lcd_putc,"2=dis-servo ");
lcd_gotoxy(1,2); }
} void main()
{
if(distancia>=60) setup_ccp1(CCP_PWM);
{ setup_ccp2(ccp_pwm);
lcd_gotoxy(1,2); setup_timer_2(T2_DIV_BY_4,249,1);
printf(lcd_putc,"ang: 180 "); enable_interrupts(int_RDA);
} enable_interrupts(GLOBAL);
for (i=0;i<=5;i++) lcd_init();
{ set_pwm1_duty(0);
putc(tring[i]); set_pwm2_duty(0);
printf(lcd_putc,"1=>Temp M.DC ");
} lcd_gotoxy(1,2);
} printf(lcd_putc,"2=dis-servo ");
IF(x=='A') while(1)
49
AMBATO-ECUADOR
{ {
lcd_gotoxy(1,1); }}
printf(lcd_putc,"1=>Temp M.DC
");
lcd_gotoxy(1,2);
printf(lcd_putc,"2=dis-servo ");
} } }
9. EJERCICIOS PROPUESTOS
Sin realización de ejercicios en la primera semana.
Ejercicio Propuesto 1
• Tema
Detector de código segmentado
• Objetivos
- General
➢ Diseñar un detector segmentado de código (11) con indicador led
- Específicos
➢ Diseñar un detector de código segmentado usando una máquina
secuencial tipo Moore
➢ Simular el detector de código.
➢ Computadora
• Desarrollo

50
AMBATO-ECUADOR
➢ Simulación Proteus
• Resultados
El diseño del detector realizado en Boole no presenta fallos, al ingresar la secuencia
detecta los códigos de manera correcta en la simulación del detector segmentado
realizado en Proteus se adiciono un led a la salida del circuito para saber cuándo ha
sido ingresado una secuencia correcta, para ingresar la secuencia se usó un
estimulador lógico, para tener control sobre el cambio de ciclo la señal CLK
también se la hace con un estímulo lógico.
• Tema
51
AMBATO-ECUADOR
• Objetivos
- General
➢ Diseñar un detector de código continuo y segmentado.
- Específicos
➢ Diseñar un detector de código continuo y segmentado usando una
máquina secuencial tipo Mealy.
➢ Diseñar un detector de código continuo y segmentado usando una
máquina secuencial tipo Moore.
➢ Simular en Proteus el detector de código de las diferentes máquinas
secuenciales.
➢ Computadora
• Desarrollo
Detector Continuo
Detector Segmentado
52
AMBATO-ECUADOR
Detector Continuo
Detector Segmentado
53
AMBATO-ECUADOR

Detector Continuo
Detector segmentado
Detector Continuo
54
AMBATO-ECUADOR
Detector Segmentado
• Resultados
Los diseños del detector de 4 bits realizados sen Boole detectan la secuencia
sin fallo alguno tanto en la máquina tipo Mealy (continuo y segmentado) y
Moore (continuo y segmentado) el cual tiene una salida para indicar la
detección de cada código.
• Tema
• Objetivos
- General
➢ Diseñar un detector de código (00)
- Específicos
➢ Diseñar un detector de código segmentado usando una máquina
secuencial tipo Mealy y Moore.
➢ Simular el detector de código en Proteus.
➢ Computadora
• Desarrollo
55
AMBATO-ECUADOR

Detector Segmentado
Detector Segmentado

Detector Segmentado
56
AMBATO-ECUADOR
Detector Segmentado
• Resultados
El diseño del detector realizado en Boole no presenta fallos, al ingresar la
secuencia detecta los códigos de manera correcta sin presentar errores. Para
tener control sobre el cambio de ciclo la señal CLK dentro de la simulación
de Proteus se la hace con un estímulo lógico
• Tema
• Objetivos
- General
➢ Diseñar un detector de código (11)
- Específicos
➢ Diseñar un detector de código continuo usando una máquina
secuencial tipo Mealy
57
AMBATO-ECUADOR
➢ Simular el detector de código en Proteus.

➢ Computadora
• Desarrollo

Detector Continuo
Detector Continuo
• Resultados
El diseño del detector continuo realizado en Boole de maquina tipo Mealy
funciona correctamente. En la simulación realizada en Proteus se puede
observar que al ingresar la secuencia este detecta los códigos sin fallo
alguno.
Tema
58
AMBATO-ECUADOR
Contador de códigos de 3 bits (101) Mealy Continuo con Flip-Flop J-K.

Objetivos
➢ General
Realizar un Contador de códigos de 3 bits (101) con el modelo de autómata
finito Mealy continuo con Flip-Flop J-K.
➢ Específicos
1. Establecer el diagrama de estados para el modelo Mealy continuo en el
software Boole Deusto.
2. Ejecutar la tabla transición de estados y salidas, y la tabla de simulación de
secuencia.
3. Llevar a cabo la tabla de diseño para obtener las funciones de estados y
salidas.
Descripción
Diseñar un contador de códigos de 3 bits (101) con el modelo de Mealy
continuo, realizar el diseño, diagrama y tablas respectivas utilizando el software
Boole Deusto e implementarlo en Proteus.
➢ Software de simulación Boole Deusto
➢ Lápiz
➢ Papel
➢ Borrador
Diagrama de estados
Ilustración 69: Diagrama de estados
Ilustración 70: Tabla de transición d estados y salidas
59
AMBATO-ECUADOR
Ilustración 71: Tabla de simulación de secuencia
Tabla de Diseño
Ilustración 72: Tabla de diseño
Ilustración 73: Entradas y Salidas con Flip-Flop J-K
Simulación
60
AMBATO-ECUADOR
Ilustración 74: Simulación

Resultados
➢ Cada una de los autómatas finitos que se analizaron dan a conocer la
forma diferente en que se podría realizar un diagrama de estados sea
usando la máquina de Mealy y Moore para su implementación.
➢ Cada una de los diagramas aplicados fueron implementada en hojas para
después aplicar en un diagrama de estados en un software llamado Boole
Deusto el cual permitió la comprobación con lo que permitirá clarificar
cada uno de las transiciones y salidas que se dio en el diagrama.
➢ La transición que toma cada uno de los estados permitió la realización de
la simulación de secuencia y tabla de diseño, a su vez se puede
implementar mediante flip-flops que son más utilizados y representados
en los mapas K.
Tema
Contador de códigos de 3 bits (101) Mealy Continuo con Flip-Flop D.
Objetivos
➢ General
finito Mealy continuo con Flip-Flop D.
➢ Específicos
1. Establecer el diagrama de estados para el modelo Mealy continuo en el
61
AMBATO-ECUADOR

secuencia.
salidas.
Descripción
continuo, realizar el diseño, diagrama y tablas respectivas utilizando el software
Boole Deusto e implementarlo en Proteus.
➢ Lápiz
➢ Papel
➢ Borrador
Diagrama de estados
Tabla de Diseño
62
AMBATO-ECUADOR
Ilustración 79: Entradas y Salidas con Flip-Flop D
Simulación
63
AMBATO-ECUADOR
Resultados
➢ Cada uno de los autómatas finitos que se analizaron deben orientar de
➢ El diseño de de los diagramas aplicados fueron implementado en hojas
para después aplicar en un diagrama de estados en un software llamado
Boole Deusto el cual permitió la comprobación con lo que permitirá
clarificar cada uno de las transiciones y salidas que se dio en el diagrama.
en los mapas K.
Tema
Contador de códigos de 3 bits (101) Mealy Segmentado con Flip-Flop J-K.
Objetivos
➢ General
finito Mealy segmentado con Flip-Flop J-K.
➢ Específicos
1. Establecer el diagrama de estados para el modelo Mealy segmentado en el
secuencia.
salidas.
Descripción
segmentado, realizar el diseño, diagrama y tablas respectivas utilizando el
software Boole Deusto e implementarlo en Proteus.
64
AMBATO-ECUADOR
➢ Lápiz
➢ Papel
➢ Borrador
Diagrama de estados
Tabla de Diseño
65
AMBATO-ECUADOR
Ilustración 85: Entradas y Salidas con Flip-Flop J-K
66
AMBATO-ECUADOR
Simulación

Resultados
67
AMBATO-ECUADOR

en los mapas K.
Tema
Contador de códigos de 3 bits (101) Mealy Segmentado con Flip-Flop D.
Objetivos
➢ General
finito Mealy segmentado con Flip-Flop D.
➢ Específicos
1. Establecer el diagrama de estados para el modelo Mealy segmentado en el
secuencia.
salidas.
Descripción
segmentado, realizar el diseño, diagrama y tablas respectivas utilizando el
software Boole Deusto e implementarlo en Proteus.
➢ Lápiz
➢ Papel
➢ Borrador
Diagrama de estados
68
AMBATO-ECUADOR
Tabla de Diseño
69
AMBATO-ECUADOR
Ilustración 91: Entradas y Salidas con Flip-Flop D
Simulación
70
AMBATO-ECUADOR
Resultados
simulación de secuencia y tabla de diseño, a su vez se puede implementar
mediante flip-flops que son más utilizados y representados en los mapas K.
Tema
Desarrollo del control de una secuencia de leds con Arduino, Pic C
Compiler mediante su simulación en Proteus.
Objetivos
General
Desarrollar el control de una secuencia de leds mediante Arduino y Pic.
Específicos
• Investigar sobre la estructura del ARDUINO y PIC C COMPILER.
• Establecer el código para el control de una secuencia de leds en
Proteus.
• Verificar el funcionamiento de la simulación con los dos software y
Proteus.
71
AMBATO-ECUADOR
Descripción
Realizar una secuencia de leds mediante la manipulación de
microcontroladores y la simulación con Proteus.

• Software Arduino
• Software Pic C Compiler
• Software Proteus
EJERCICIO 1
Ilustración 181 Código de Programación ARDUINO
Ilustración 182 DIAGRAMA DE PROTEUS CON EJECUTABLE DE ARDUINO
72
AMBATO-ECUADOR
Ilustración 183 Código de Programación de PIC
Ilustración 184 DIAGRAMA DE PROTEUS CON EJECUTABLE DE PIC
ARDUINO IDE PIC

int boton1=1; #include <16F877a.h>
int boton2=2; #fuses HS, NOWDT //HS MAYOR A 4
int led1=7; MEGAHERTS
int led2=8; #Use delay (clock= 8M)
int led3=9;
int led4=10; VOID MAIN(){
int led5=11; SET_TRIS_C(0b11111111); asigno al
int led6=12; puerto d Como entrada
int led7=13; while(TRUE) {
int estado; if((input (pin_c0)--
int estado2; 1)&&(input(pin_c1)--0)) //condicion
para verificar que solo un pulsador esté
void setup() { activo
// put your setup code here, to run once: {
pinMode(led1,OUTPUT); output_high(pin_bo) ; //encendido
pinMode(led2,OUTPUT); led en la posición b0
73
AMBATO-ECUADOR
pinMode(led3,OUTPUT); delay_ms(300); //espero 300ms

pinMode(led4,OUTPUT); output_low(pin_b0) ; // apagado
pinMode(led5,OUTPUT); del led b0
pinMode(led6,OUTPUT); delay_ms(300) ;
pinMode(led7,OUTPUT); output_high(pin_b1) ;
pinMode(boton1,INPUT); delay_ms(300) ;
pinMode(boton2,INPUT); output_low(pin_b1) ;
delay_ms(300) ;
} output_high(pin_b2) ;
delay_ms(300) ;
void loop() { output_low(pin_b2) ;
estado2 = digitalRead(boton2);//on off delay_ms(300) ;
if(estado2==HIGH){ output_high(pin_b3) ;
digitalWrite(led1,HIGH); //muestra del delay_ms(300) ;
led output_low(pin_b3) ;
delay (500); delay_ms(300) ;
digitalWrite(led2,HIGH); //muestra del output_high(pin_b4) ;
led delay_ms(300) ;
delay (500); output_low(pin_b4) ;
led output_high(pin_b5) ;
digitalWrite(led4,HIGH); //muestra del output_low(pin_b5) ;
led delay_ms(300) ;
delay (500); output_high(pin_b6) ;
led delay_ms(300) ;
led }
delay (500); if((input (pin_c0)==0)&&|input
} |pin_c1)==1) //condicion 2
else{ {
digitalWrite(led7,LOW); //muestra del output_high(pin_b7) ;
led delay_ms(300) ;
digitalWrite(led6,LOW); //muestra del delay_ms(300) ;
digitalWrite(led5,LOW); //muestra del output_low(pin_b6) ;
led delay_ms(300) ;
74
AMBATO-ECUADOR

led delay_ms(300) ;
digitalWrite(led1,LOW); //muestra del output_low(pin_b3) ;
led delay_ms(300) ;
} delay_ms(300) ;
if(estado==HIGH){ output_low(pin_b2) ;
digitalWrite(led6,HIGH); //muestra del output_low(pin_b1) ;
led delay_ms(300) ;
delay (500); output_high(pin_bo) ;
digitalWrite(led4,HIGH); //muestra del }
led
delay (500);
digitalWrite(led3,HIGH); //muestra del
led
delay (500);
led
delay (500);
led
delay (500);
}
else{
digitalWrite(led1,LOW); //muestra del
led
delay (500);
led
delay (500);
led
delay (500);
led
delay (500);
led
75
AMBATO-ECUADOR
delay (500);
led
delay (500);
led
delay (500);
}
EJERCICIO 2
Descripción: Control de giro de un motor con 3 diferentes velocidades
Control de menú principal Control giro Control velocidad
ON: * A: derecha 7: velocidad 1
OFF : # D: izquierda 8: velocidad 2
9: velocidad 3
Ilustración 185 MENÚ para encendido y apagado
Ilustración 186 Menú par giro derecha e izquierda
76
AMBATO-ECUADOR
Ilustración 187 giro derecha con velocidad 1
Ilustración 188 giro derecha con velocidad2
Ilustración 189 giro derecha con velocidad 3
Ilustración 190 giro izquierda con velocidad 1
77
AMBATO-ECUADOR
Ilustración 193 sistema apagado
CODIGO EN PIC C COMPILER
78
AMBATO-ECUADOR
#include <16F887.h> //LIBRERÍA

PARA EL MANEJO DEL PIC 16f887 void main()
#fuses HS,NOWDT,MCLR,NOLVP // {
hs ' CONFIGURACION DEL set_tris_b(0x01); //DECLARACION
OSCILADOR PARA FRECUENCIAS DEL PUERTO B COMO ENTRADA
MAYORES A 4MHZ set_tris_a(0x00); //DECLARACION
#use delay (clock=8M) // DEL PUERTO a COMO SALIDA
DECLARACION DEL OSCILADOR set_tris_d(0x00); //DECLARACION
#use fast_io(B) DEL PUERTO d COMO SALIDA
#use fast_io(D) set_tris_c(0x00); //DECLARACION
#use fast_io(C) DEL PUERTO c COMO SALIDA
#use fast_io(A) output_c(0x00); //LIMPIEZA DEL
#define LCD_DB4 PIN_D4 PUERTO C PARA QUE INICIE EN 0
//definimos el LCD en el Port_D output_a(0x00);
#define LCD_DB5 PIN_D5
#define LCD_DB6 PIN_D6 port_b_pullups(true);
#define LCD_DB7 PIN_D7 lcd_init();
//#define retardo delay_ms(500) kbd_init();
#define LCD_RS PIN_D2
#define LCD_E PIN_D3 //#define //VISUALIZACION DEL MENSAJE
use_portb_kbd TRUE INICIAL
#include <lcd1.c> lcd_gotoxy(1,1);
#include <teclado.c> lcd_putc("Pulse * para: ON");
char teclado; lcd_gotoxy(1,2);
int tiempo; lcd_putc("Puls # para: OFF");
void encendido()
{ while (True)
lcd_putc("\f"); {
lcd_gotoxy(1,1); teclado = kbd_getc();
lcd_putc(" Sistema ON "); if(teclado!=0)
lcd_gotoxy(1,2); {
lcd_putc("A->DER - D->IZQ "); if(teclado == '*')
output_a(1); {
} encendido();
void giro_derecha() while(teclado!='#')

{ {
lcd_gotoxy(1,1); teclado=kbd_getc();
lcd_putc(" Sistema ON "); // giro derecha
lcd_gotoxy(1,2); if(teclado=='A')
lcd_putc("G=Dere "); {
output_c(1); velocidad1();
delay_ms(tiempo); output_a(11);
output_c(2); while(true){
delay_ms(tiempo); giroDerecha:
output_c(4);
delay_ms(tiempo); giro_derecha();
output_c(8); teclado = 0;
delay_ms(tiempo);
} teclado=kbd_getc();
if(teclado!=0){
void giro_izquierda()
8
AMBATO-ECUADOR
{ if(teclado == 'D') {
lcd_gotoxy(1,1); output_low(pin_a1);
lcd_putc(" Sistema ON "); output_high(pin_a2); goto
lcd_gotoxy(1,2); giroIzquierda;}
lcd_putc("G=Izqu "); else if(teclado == '#') {goto
output_c(8); off;}
delay_ms(tiempo); else if(teclado == '1')
output_c(4); {output_a(11); velocidad1();}
delay_ms(tiempo); }
} } }
void apagado() // giro izquierda

{
lcd_putc("\f"); if(teclado=='D')
lcd_gotoxy(1,1); {
lcd_putc("SISTEMA APAGADO"); velocidad1();
lcd_gotoxy(1,2); output_a(13);
lcd_putc("*-> ON"); while(true){
} giroIzquierda:
giro_izquierda();
void velocidad1() teclado = 0;
{
lcd_gotoxy(9,2); teclado=kbd_getc();
lcd_putc("Velo=1 "); if(teclado!=0){
tiempo=100; if(teclado == 'A')
} {output_high(pin_a1);
output_low(pin_a2); goto giroDerecha;}
void velocidad2() else if(teclado == '#') {goto
{ off;}
lcd_putc("\f"); else if(teclado == '1') {
lcd_gotoxy(9,2); output_a(13); velocidad1();}
lcd_putc("Velo=2 "); else if(teclado == '2') {
tiempo=50; output_a(21); velocidad2();}
} else if(teclado == '3') {
output_a(37); velocidad3();}
void velocidad3() }
{
lcd_putc("\f"); }
lcd_gotoxy(9,2); }
lcd_putc("Velo=3 ");
tiempo=10; } // end while(teclado!=D)
}
goto off;
}
off:
output_a(0);
output_c(0);
9
AMBATO-ECUADOR
apagado();
}
}
}
1. Realizar un programa que permita controlar el giro horario y antihorario de un motor a

pasos, mediante el uso de interruptor que cambien el sentido, y además un potenciómetro
que regule la velocidad del mismo.
2.Realizar un programa que permita controlar la velocidad de un motor mediante un sensor
de temperatura LM35
• TEMA
Control Básico de Motor a pasos
• OBJETIVOS
- Objetivo General
Desarrollar un programa que permita controlar el giro de un motor a pasos.
Realizar la programación para un microcontrolador ATMega
Simular y verificar el funcionamiento del sistema usando el software Proteus.
- Software Arduino IDE
- Software Proteus
- Computadora
- Apuntes de clases
• DESCRIPCION
Realizar un programa que permita controlar el giro horario y antihorario de un motor
a pasos, mediante el uso de interruptor que cambien el sentido, y además un
potenciómetro que regule la velocidad del mismo.
• DESARROLLO
1. #include <Stepper.h>
2. #define STEPS 4
3. Stepper stepper(STEPS, 8, 9, 10, 11);
4.
5. const int boton = 4;
6. const int pot = A0;
7.
8. void setup()
9. {
10.
11. pinMode(boton, INPUT_PULLUP);
12. }
10
AMBATO-ECUADOR
13.
14. int dir_ = 1, speed_ = 0;
15.
16. void loop()
17. {
18. if ( digitalRead(boton) == 0 )
19. if ( debounce() )
20. {
21. dir_ *= -1;
22. while ( debounce() ) ;
23. }
24. int val = analogRead(pot);
25.
26. if ( speed_ != map(val, 0, 1023, 5, 100) )
27. {
28. speed_ = map(val, 0, 1023, 5, 100);
29.
30. stepper.setSpeed(speed_);
31. }
32.
33. stepper.step(dir_);
34.
35. }
36.
37. bool debounce()
38. {
39. byte count = 0;
40. for(byte i = 0; i < 5; i++) {
41. if (digitalRead(boton ) == 0)
42. count++;
43. delay(10);
44. }
45. if(count > 2) return 1;
46. else return 0;
47. }
Ilustración 194: Ejercicio Propuesto 1
11
AMBATO-ECUADOR
• TEMA
Control de velocidad de un motor mediante un sensor de temperatura LM35.
• OBJETIVOS
- General:
Conocer el funcionamiento de las señales PWM mediante la aplicación del
control de velocidad de un motor DC con un sensor de temperatura.
- Específicos:
Aplicar el uso de señales PWM.
Controlar los parámetros para determinar correctamente el ancho de pulso de
la frecuencia del C.I.
- Software PIC C Compiler
- Software Proteus
- Computadora
- Apuntes de clases
• DESCRIPCION
La presente practica plantea el uso de señales PWM para control de un motor
DC mediante un sensor de temperatura para lo cual se usará PIC.
En el caso del PIC podemos usar frecuencias diferentes al poder acoplarle un
oscilador externo por lo que se debe calcular su valor de pre-escalamiento, en
este caso se ha trabajado con 4MHz.
• DESARROLLO
48. #include <16f887.h>
49. #device adc=10
50. #fuses intrc,hs
51. #use delay (clock=4M)
52. #include <lcd.c>
53. float t,m;
54. int16 s;
55. void main(){
56. setup_adc_ports(all_analog);
57. setup_adc(adc_clock_internal);
58. lcd_init();
59. set_tris_c(0b000);
60. setup_timer_2(t2_div_by_16,62,1);
61. setup_ccp1(ccp_pwm);
62. while(TRUE){
63. set_adc_channel(0);
64. delay_ms (1);
65. s=read_adc();
66. m=s*0.83;
67. t=(s*0.4883);
68. lcd_gotoxy(1,1);
69. printf(lcd_putc,"Temp= %6.3f",t);
70. lcd_gotoxy(1,2);
71. printf(lcd_putc,"PWM= %6.0f",m);
72. set_pwm1_duty(s);
73. delay_ms(1000);
74. }
12
AMBATO-ECUADOR
Ilustración 195: Ejercicio Propuesto 2
1. TEMA 6 (Poner tema)
Ejercicio propuesto 1
• Tema:
Control de acceso seguro mediante un teclado matricial y visualización en LCD

mediante el uso de arduino y pics.
• Objetivos:
▪ General
• Construir un control de acceso seguro mediante un teclado matricial y
visualización en LCD mediante el uso de arduino y pics.
▪ Específicos
• Definir parámetros para la programación tanto en la interfaz arduino
como en la de pic c compiler.
• Desarrollar la simulación en proteus y verificar resultados y realizarlo

en la plataforma tinkercad el circuito de arduino
• Descripción
Realizar un ejercicio que defina el control de acceso seguro para esto usaremos un
teclado el cual nos ayudara en primera instancia a preguntar que ponga la clave y si
13
AMBATO-ECUADOR
este sistema es correcto que encenderá un led de verificación y si es incorrecto

después de tres intentos se cerrara.
• Listado de Materiales y Equipos
▪ Computador
• Diagramas y Esquemas
PROGRAMACIÓN ARDUINO {'7','8','9','A'},

{'4','5','6','B'},
#include <LiquidCrystal.h> {'1','2','3','C'},
#include <Key.h> {'*','0','#','D'}
#include <Keypad.h> };
int a=0, b=0, c=0, d=0;//acumuladores de byte pinFilas[filas] = {7, 6, 5, 4}; //conectarse
datos enteros para la contrseña. a las patillas de salida de fila del teclado.
int var=0; //incremento apara el switch. byte pinColumnas[columnas] = {3, 2, A4,
int A5}; //conectarse a las patillas de las
C1=1,C2=2,C3=3,C4=4;//contraseña....Ustede columnas del teclado.
s pueden codificarlo la contraseña
char f='*'; //caracter para cubrir la Keypad keypad = Keypad(
contraseña. makeKeymap(tecla), pinFilas, pinColumnas,
int veces=0,incorrecto=0; //seguridad de solo filas, columnas );
3 intentos para ingresar la contraseña correcta. LiquidCrystal lcd(13,12,11,10,9,8);
int aviso=3; //aviso para mostrar los intentos //RS,E,D4,D5,D6,D7
como seguridad para el usuario. void setup(){
const byte filas = 4; //cuatro filas. lcd.begin(16,2); //LCD (16 COLUMNAS Y
const byte columnas = 4; //cuatro columnas. 2 FILAS)
char tecla[filas][columnas] = {
14
AMBATO-ECUADOR
pinMode(A0,OUTPUT); //TRUE delay(400);

PASSWORD CORRECTO LED YELLOW. lcd.clear();
pinMode(A1,OUTPUT); //FALSE digitalWrite(A1,LOW);
PASSWORD INCORRECTO LED RED. }
} //------Seguridad para la contraseña y sus
restricciones-------------------//
void loop(){
char key = keypad.getKey(); if(a==C1 && b==C2 && c==C3 &&
if (key){ d==C4){
lcd.setCursor(5+var,1); veces=0;//si es correcto el password
,variable veces no se incremeta.
lcd.print(key),lcd.setCursor(5+var,1),lcd.print aviso=3;//variable aviso se mantiene en 3
(f);//imprimimos el caracter en el lcd }
key=key-48; //COVERCIÓN DE CHAR A else{
ENTEROS -48 SEGUN EL CÓDIGO ASCII. veces ++; //incrementamos los intentos
var++; //var se incrementa para los incorrectos de password para el bloqueo.
case1,case2,case3,case4. aviso --; //decremento de variable aviso
switch(var){ ,de 3 hasta 0 según las veces de fallas al
case 1: ingresar el password.
a=key; //almacenamos primer dígito para la lcd.setCursor(2,0);
contraseña que seria el 1 lcd.print("LE QUEDA: ");
break; lcd.setCursor(13,0);
case 2: lcd.print(aviso);
b=key; //almacenamos segundo dígito para lcd.setCursor(2,1);
la contraseña que seria el 2 lcd.print("OPORTUNIDAD");
break; if(aviso==0){
case 3: lcd.clear();
c=key; //almacenamos tercer dígito para la lcd.setCursor(5,0);
contraseña que seria el 3 lcd.print("ALARMA");
break; lcd.setCursor(4,1);
case 4: lcd.print("ACTIVADO");
d=key; //almacenamos cuarto dígito para la }
contraseña que seria el 4 delay(300);lcd.clear();
delay(100); }
if(a==C1 && b==C2 && c==C3 &&
d==C4){ while(veces>=3){
lcd.clear(); lcd.setCursor(1,0),lcd.print("Alerta
lcd.setCursor(3,0); Policia");
lcd.print("Password"); lcd.setCursor(4,1),lcd.print("Intrusos");
lcd.setCursor(3,1); digitalWrite(A1,HIGH);
lcd.print("Correcto"); delay(100);
digitalWrite(A0,HIGH); lcd.clear();
delay(700); digitalWrite(A1,LOW);delay(50);
lcd.clear(); }//while es Bucle infinito de seguridad para
digitalWrite(A0,LOW); bloquear los re intentos del password
}
else{ var=0;
lcd.clear(); lcd.clear();
lcd.setCursor(3,0);
lcd.print("Password"); break;//se termina el
lcd.setCursor(2,1); }
lcd.print("Incorrecto");
digitalWrite(A1,HIGH); }
9
AMBATO-ECUADOR
if(!key){lcd.setCursor(0,0),lcd.print("Digite delay(2);
Password");}//portada de inicio en el LCD }
PROGRAMACIÓN EN PIC C COMPILER
Ilustración 19.- Programación en pic
PROGRAMACIÓN PIC printf(lcd_putc, "Ingresa la clave");

output_A(0x02);
#include
"C:\Users\dell\Desktop\Ejercicio_\cerradura_ if((K!=0)&&(K!='#')&&(K!='*'))
bien.h"
#use delay (clock=20Mhz) {
#fuses hs, nowdt lcd_gotoxy(X, 2);
#include <LCD.C> //Incluimos librerias printf(lcd_putc, "%c", K);
#include <KBD1.C> D[X]=K;
X++;
int X=1; }
int i, Y; if ((K!=0)&&(K=='*')){
char K;
char C[]={'0', '3', '4', '5', '6'}; i=0;
char D[]={"00000"}; for(i=0; i<5; i++)
{
void main(){ if(D[i]!=C[i])
set_tris_A(0x00); {
lcd_init(); break;
kbd_init(); }
port_b_pullups(true); }
if(i==5)
do{ {
K=kbd_getc(); do {
lcd_gotoxy(1,1); K=kbd_getc();
10
AMBATO-ECUADOR
lcd_gotoxy(1,2); if((K!=0)&&(K=='#')){
printf(lcd_putc, "CLAVE
CORRECTA"); X--;
output_A(0x01); D[X]='0';
Y=0; lcd_gotoxy(X,2);
} printf(lcd_putc," ");
while(K!='*'); } }
X=1;
D="00000"; if(X==0){
i=0;
printf(lcd_putc,"\f"); X=1;
delay_ms(50); }
} if(Y==3)
{
else { do {
lcd_gotoxy(1,2);
printf(lcd_putc, "CLAVE printf(lcd_putc, "\f SISTEMA
INCORRECTA"); BLOQUEADO");
delay_ms(600); delay_ms(10);
X=1; }
Y++;
D="00000"; while(true);
i=0; }}
printf(lcd_putc, "\f");
} while(true);
}
• Resultados
Cómo podemos observar nos pide la contraseña la digitamos y si no es la correcta nos dará
contraseña incorrecta y si es se abrirá el circuito.
ARDUINO
9
AMBATO-ECUADOR
PIC
• Tema:
Sistema de visualización de caracteres del teclado matricial.
• Objetivos:
▪ General
• Construir sistema de visualización de caracteres del teclado matricial

mediante el uso de arduino y pic.
▪ Específicos
9
AMBATO-ECUADOR
• Definir parámetros para la programación tanto en la interfaz arduino como en

la de pic c compiler.
• Desarrollar la simulación en proteus y verificar resultados y realizarlo en la

plataforma tinkercad el circuito de arduino
• Descripción
Realizar un ejercicio que defina la visualización de caracteres de un teclado matricial

y que se pueda observar en la lcd.
• Listado de Materiales y Equipos
▪ Computador
• Diagramas y Esquemas
PROGRAMACIÓN ARDUINO //DESCRIPCIÓN DE CARATERES QUE SE

PRESENTA EL TECLADO
#include <LiquidCrystal.h> //INCLUIMOS
LA LIBRERIA DE LIQUIDCRYSTAL {'1','2','3','A'},
LiquidCrystal lcd(12,11,5,4,3,2); {'4','5','6','B'},
#include <Keypad.h> //INCLUIMOS LA {'7','8','9','C'},
LIBRERIA DE KEYPAD {'*','0','#','D'},
//DESCRIPCION DE FILAS Y COLUMNAS };
const byte FILAS=4; //PINES DE ENTRADA DE DATOS DE

const byte COLUMNAS=4; TECLADO
char hexaKeys[FILAS][COLUMNAS]={
byte FILASpins[FILAS]={7,6,1,0};
10
AMBATO-ECUADOR
byte void loop() {

COLUMNASpins[COLUMNAS]={13,10,9,8
}; //OBTENCIÓN DE CARÁCTER ENVIADO
DEL TECLADO
//INICIAMOS LA LÍBRRIA Y LA
CONFIGURACIÓN DE LA MATRIZ DEL char tecla=customKeypad.getKey();
TECLADO lcd.display();
Keypad customKeypad = //CONDICIÓN PARA DETECCIÓN DE

Keypad{makeKeymap(hexaKeys),FILASpins TECLADO PULSADA
,COLUMNASpins,FILAS,COLUMNAS};
if(tecla){
//VARIABLES DE MOVIMIENTOS DE lcd.setCursor(cuadro,fila);
TEXTO lcd.print(tecla);
int cuadro=0; //IMPRESIÓN DE LOS DATOS

int fila=0;
cuadro++;
void setup() { if(cuadro>15){
//DESCRIPCIÓN DEL TIPO DE LCD //VOLVER A EMPEZAR EL CICLO

//INICIALIZACIÓN DEL CURSOR
cuadro=0;
lcd.begin(16,2); fila=1;
lcd.setCursor(0,0);
}
} }
}
ROGRAMACIÓN EN PIC C COMPILER
Ilustración 24.- Programación en pic [Fiallos D., Rivera C., Lascano A., Tinta C.]
PROGRAMACIÓN PIC
#INCLUDE <16F887.H>
#fuses XT
#use delay(clock=4M)
#use rs232(baud=9600,xmit=pin_c6,rcv=pin_c7,parity=N,bits=8,stream=PORT1)
9
AMBATO-ECUADOR
#USE DELAY(CLOCK=4000000)
#FUSES XT,NOPROTECT,NOWDT,NOBROWNOUT,NOPUT,NOLVP
#DEFINE USE_PORTB_KBD
#INCLUDE <LCD.C>
#INCLUDE <KBD4x4_1.C> //Incluir en while (DIR<17) // El maximo de
el encabezado el driver para digitos en el lcd es 16
#use standard_io(b) // Como un puerto {
estandar de entrada y salida if(k!='\0'){ // Guarda los
#byte PORTB= 6 //Direcciones de caracteres que se capturan del teclado...El '\0'
memoria de los puertos es un karacter que se guarda en la variable k
#BYTE PORTD= 8 LCD_GOTOXY(DIR,2); // Direcion
INT DIR; en el caso que haya ingresado un caracter
lcd_putc(k); // Imprimo lo que
// FUNCION TECLA //Captura los datos hay en el caracter k
del teclado k='\0'; //Indica que el caracter
char tecla(void) // Funcion encargada de esta vacio
esperar a que se presione una tecla DIR++; //Incrementa en uno a
{ la derecha del LCD
char c; //Define una variable caracter }
c k=tecla(); //Lee el valor del
do{ //espera hasta que se presione teclado y espera hasta que alguna tecla se
una tecla pulse
c=kbd_getc(); // c Queda preguntando por if(DIR>16)
el teclado LCD_PUTC("\f");
} }
while(c=='\0'); //mientras sea difeente a la }
vable nula
return(c); //Retona la tecla digitada
}
VOID MAIN()
{
CHAR K; // Variable donde
vamos acumular los valores del teclado
port_b_pullups (0xFF); //Utiliza las
resistencias PULL UP internas del puerto B
SET_TRIS_B(0); //salidas
LCD_INIT(); //Inicializar del
lcd
KBD_INIT(); //Inicializar del
teclado Matricial
LCD_PUTC("\f"); //Borro la
pantalla LCD
WHILE(1)
{
DIR=1; //Inicializamos la
direccion en la pocicion 1
LCD_GOTOXY(1,1); // Ubicacomo
el mesaje Teclas ingresadas
LCD_PUTC("Teclas Ingresadas:");
LCD_GOTOXY(1,2); //Ubica el
cursor del LCD en la siguiente linea
9
AMBATO-ECUADOR
• Resultados
Como podemos observar en las dos simulaciones el resultado es el esperado
ARDUINO

PIC
7. Comunicaciones
Tema Control de intensidad
Objetivos
• General
➢ Controlar la intensidad de un LED utilizando señales de un potenciómetro
• Específicos
➢ Utilizar arduino para controlar la intensidad de un LED
➢ Demostrar el porcentaje de trabajo del potenciómetro
Descripción
Diseñar un sistema que controle la intensidad de un led mediante un potenciómetro
22
AMBATO-ECUADOR
• Debe contar con un LCD que muestre el valor que está tomando el potenciómetro
• Debe mostrar el porcentaje que se está mostrando (0-100%)
• Arduino IDE
• Placa Arduino
• Led
• Potenciómetro
PIC C COMPILER ser valores 1,4,16, timer2, poscaler
#INCLUDE <16f887.H> configuramos el pwm
#device adc=10 //trabajar a 10 bits en LCD_INIT(); //Inicializar el driver
la conversion analogo digital del lcd
#USE DELAY(CLOCK=4000000) WHILE(1) { //Lectura ADC
#FUSES//XT,NOPROTECT,NOWDT set_adc_channel(0//Selecciono el
,NOBROWNOUT,NOPUT,NOLVP canal 0 (RA0)
#INCLUDE <LCD.C>
float duty=0;//Variable almacena ciclo duty=read_adc();tem=(duty*500)/102
de trabajo los bits de 0-255 4;
float tem;//Almacena la temperatura //Conversion de bits a temperatura
int Timer2, Poscaler; // configuracion 0.4882
del timer 2 volt1=tem/100;
float volt1; lcd_gotoxy(1,1);
#define s1 pin_A3 //salida uno del printf(lcd_putc, "VPOT=
driver %1.1f",duty); //Muestra el valor
#define s2 pin_A4 // salida 2 del numerico de la conversion
driver lcd_gotoxy(1,2);
#use standard_io(A) printf(lcd_putc, "V= %f",volt1);
///Para mapear los datos if(tem>30){
double map(double value, float x_min, int32 duty0=map( tem, 30, 80, 0,
float x_max, float y_min, float 100);
y_max); int32 final=map( duty0, 0, 100, 0,
VOID MAIN(){ 1023);
setup_adc_ports(sAN0);//Pongo int d=final/10;
RA0 como analogo output_low(s2);
setup_adc(adc_clock_internal); output_high(s1);
//Selecciono reloj interno para set_pwm1_duty(final);}}}
conversion analogo digital double map(double value, float x_min,
set_tris_a(0b00000001); float x_max, float y_min, float y_max)
//Pongo el RA0 como entrada {return (y_min + (((y_max -
Timer2=249; // es un timer de 8 y_min)/(x_max - x_min)) * (value -
bits. El timer 2 tine un prescaler y un x_min)));
poscaler }
Poscaler=1; //en la configuracion
del timer 2 el poscaler debe tener un ARDUINO
valor de 1
setup_timer_2(t2_div_by_4,Timer2,Po #include <LiquidCrystal.h>;
scaler); //t2_div_by_4=prescaler puede LiquidCrystal lcd(9, 8, 7, 13, 12, 11,
23
AMBATO-ECUADOR
10);
int LED=3;
float POT=A0;
float t=0;
int bri;
void setup() {
pinMode(LED, OUTPUT);
pinMode(POT, INPUT);
lcd.begin(16,2);
Serial.begin(9600);}
void loop() {
//VELOCIDAD DE ACUERDO A LA
TERMPERATURA
bri=analogRead(POT);
t=((bri*10/1023)*10);
analogWrite(LED,bri);
//MUESTRA DE TEMPERATURA
EN LCD
lcd.setCursor(0,0);
lcd.print("Valor:");
lcd.setCursor(6,0);
lcd.print(bri );
lcd.setCursor(0,1);
lcd.print("%Pot:");
lcd.print(t);
delay(100);
lcd.clear();}
Resultados
Ilustración 38: Valor potenciómetro
5
AMBATO-ECUADOR
Ilustración 39: Valor al 100%
Tema
Comunicación Inalámbrica
Objetivos
• General
➢ Desarrollar una comunicación inalámbrica que nos permita enviar datos mediante
la comunicación Bluetooth
• Específicos
➢ Realizar la programación para ambos microcontroladores tanto para PIC Y Atmega
➢ Realizar la simulación de ambos microcontroladores para la visualización de
resultados
Descripción
Diseñar un sistema de comunicación inalámbrico para un teclado matricial en el cual se
envíen los caracteres del teclado a otro microcontrolador mediante bluetooth, además debe
contar con las siguientes características:
• Debe contar ambos microcontroladores pantallas LCD para que se pueda visualizar el dato
enviado y el dato recibido
• El teclado matricial debe ir conectado en el microcontrolador que actúa de Master
• Simulación tanto para microcontrolador PIC y arduino
• Software de programación Pic C Compiler
• Arduino IDE
• Teclado matricial 4x4
• Microcontrolador PIC 16F887
• Placa Arduino
LiquidCrystal lcd(10, 11, 12, 13, A0,

Arduino A1);
const byte fil = 4;
#include <Keypad.h> const byte col = 4;
#include <LiquidCrystal.h>; byte pinfil[] = {9,8,7,6};
28
AMBATO-ECUADOR
byte pincol[] = {5,4,3,2}; if (c =='6') {lcd.setCursor(8,1);

byte teclas [4] [4] = {{'7','8','9','A'}, lcd.print('6');
delay(100);}
{'4','5','6','B'}, if (c =='7')
{'1','2','3','C'}, {lcd.setCursor(8,1);
{'*','0','#','D'}}; lcd.print('7');
Keypad delay(100);}
teclado=Keypad(makeKeymap(teclas) if (c =='8')
{lcd.setCursor(8,1);
, pinfil, pincol, fil, col); lcd.print('8');
void setup() delay(100);}
{ lcd.begin(16,2); if (c =='9')
lcd.setCursor(0, 0); {lcd.setCursor(8,1);
lcd.print("Tecla Presionada"); lcd.print('9');
delay(100);}
Serial.begin(9600);} if (c =='0')
void loop(){ {lcd.setCursor(8,1);
char tecp=teclado.getKey(); lcd.print('0');
if (tecp != NO_KEY)//(si se presiona delay(100);}
if (c =='A')
una tecla){ {lcd.setCursor(8,1);
lcd.setCursor(8,1);//ubicamos el cursor lcd.print('A');
lcd.print(tecp); delay(100);}
delay(100);}
Serial.write(tecp);}
RECEPTOR
#include <LiquidCrystal.h>;
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);
int c;
void setup()
{ lcd.begin(16,2);
lcd.print("Tecla Presionada");
Serial.begin(9600);}
void loop() {
if(Serial.available()){
c=Serial.read();
if (c =='1') {lcd.setCursor(8,1);
lcd.print('1');
delay(100);}
if (c =='2'){lcd.setCursor(8,1);
lcd.print('2');
delay(100);}
lcd.print('3');
delay(100);}
lcd.print('4');
delay(100);}
lcd.print('5');
delay(100);}
5
AMBATO-ECUADOR
Resultados
Ilustración 40: Tecla Enviada Ilustración 41: Tecla Recibida
while(c=='\0');
PIC C COMPILER return(c);}
EMISOR char teclado() {
unsigned int16 timeout;
#INCLUDE <16F887.H> timeout=0;
#FUSES//XT,NOPROTECT,NOWDT,NOBR tec=kbd_getc(); // Valor del teclado
OWNOUT,NOPUT,NOLVP while(tec=='\0' && (++timeout<
#use delay(clock=4M) (200*100))){
#define LCD_ENABLE_PIN PIN_D0 delay_us(5);
#define LCD_RS_PIN PIN_D1 tec=kbd_getc(); // Valor del teclado}
#define LCD_RW_PIN PIN_D2 return(tec);}
#define LCD_DATA4 PIN_D4 void menu(){
#define LCD_DATA5 PIN_D5 tec=teclado();//lectura teclado
#define LCD_DATA6 PIN_D6 if(tec!=0){
#define LCD_DATA7 PIN_D7 if(tec=='0'){//regresar
#use rs232(baud=9600,xmit=pin_c6, } espera ();
rcv=pin_c7, parity=N, bits=8, if(c=='1'){putc('1');
stream=PORT1) lcd_gotoxy(1,2);
#DEFINE USE_PORTB_KBD lcd_putc('1');}
#INCLUDE <LCD.C> if(c=='2'){putc('2');
#INCLUDE <KBD4x4.C> //Incluir en el lcd_gotoxy(1,2);
encabezado lcd_putc('2');}
#use standard_io(b) if(c=='3'){putc('3');
#byte PORTB= 6 //Direcciones de lcd_gotoxy(1,2);
memoria lcd_putc('3');}
#BYTE PORTD= 8 if(c=='3'){putc('3');
#byte portc=7 lcd_gotoxy(1,2);
#byte portb=6 lcd_putc('1');}
#byte portd=8 if(c=='4'){putc('4');
#byte porta=5 lcd_gotoxy(1,2);
char tec='\0'; lcd_putc('4');}
char c; if(c=='5'){putc('5');
//lectura del teclado lcd_gotoxy(1,2);
char espera (){ lcd_putc('5');}
do {c=kbd_getc(); //Captura valor del if(c=='6'){putc('6');
teclado} lcd_gotoxy(1,2);
30
AMBATO-ECUADOR
lcd_putc('6');} lcd_gotoxy(1,1);// fila/columna=(1,1)

if(c=='7'){putc('7');} lcd_putc("Tecla Presionada");
if(c=='8'){putc('8');} if(recibido=='1'){if(recibido!='\0'){
if(c=='9'){putc('9');} LCD_GOTOXY(1,2);
if(c=='*'){putc('*');} lcd_putc(recibido);
if(c=='0'){putc('0');} recibido='\0';
if(c=='#'){putc('#');} delay_ms(100);}}
if(c=='A'){putc('A');} if(recibido=='2'){
if(c=='B'){putc('B');} if(recibido!='\0'){
if(c=='C'){putc('C');} LCD_GOTOXY(1,2);
if(c=='D'){putc('D');}}} lcd_putc(recibido);
//fpincipal recibido='\0';
void main(){ delay_ms(100);}}
kbd_init();//iniciar teclado if(recibido=='3'){if(recibido!='\0'){
lcd_init();//iniciar LCD LCD_GOTOXY(1,2);
port_b_pullups(0xFF);//activacion de lcd_putc(recibido);
resistencias pullups recibido='\0';
lcd_gotoxy(1,1); delay_ms(100);}}
lcd_putc("Tecla presionada"); if(recibido=='4'){if(recibido!='\0'){
while(TRUE){ LCD_GOTOXY(1,2);
menu();}} lcd_putc(recibido);
recibido='\0';
RECEPTOR delay_ms(100);}}
if(recibido=='5'){if(recibido!='\0'){
#include <18f4550.h> LCD_GOTOXY(1,2);
#fuses INTRC_IO,HS//utilizar oscilador lcd_putc(recibido);
interno recibido='\0';
#DEVICE ADC=10// adc de 8 bITS delay_ms(100);}}
#use delay(internal=4M) if(recibido=='6'){if(recibido!='\0'){
#use//rs232(baud=9600,xmit=pin_c6,rcv=pin LCD_GOTOXY(1,2);
_c7,parity=N,bits=8,stream=PORT2) lcd_putc(recibido);
#define LCD_ENABLE_PIN PIN_D2 recibido='\0';
#define LCD_RS_PIN PIN_D0 delay_ms(100);}}
#define LCD_RW_PIN PIN_D1 if(recibido=='7'){if(recibido!='\0'){
#define LCD_DATA4 PIN_D3 LCD_GOTOXY(1,2);
#define LCD_DATA5 PIN_D4 lcd_putc(recibido);
#define LCD_DATA6 PIN_D5 recibido='\0';
#define LCD_DATA7 PIN_D6 delay_ms(100);}}
#include <lcd.c> if(recibido=='8'){
#byte porta = 0xf80 // Ppuerto A. if(recibido!='\0'){
#byte portb = 0xf81 // PuertoBB. LCD_GOTOXY(1,2);
#byte portc = 0xf82 // Puerto C lcd_putc(recibido);
#byte portd = 0xf83 // Puerto D recibido='\0';
#byte porte = 0xf84 // Puerto E delay_ms(100);}}
char recibido; if(recibido=='9'){if(recibido!='\0'){
#int_RDA// interrupcion serial LCD_GOTOXY(1,2);
void RDA_isr(void){ //RDA_isr() lcd_putc(recibido);
{recibido=getc();} recibido='\0';
recibido=getchar();} delay_ms(100);}}
void recibir(){ if(recibido=='*'){if(recibido!='\0'){
31
AMBATO-ECUADOR
LCD_GOTOXY(1,2);
lcd_putc(recibido);
recibido='\0';
delay_ms(100);}}
if(recibido=='0'){if(recibido!='\0'){
LCD_GOTOXY(1,2);
lcd_putc(recibido);
recibido='\0';
delay_ms(100);}}
if(recibido=='#'){if(recibido!='\0'){
LCD_GOTOXY(1,2);
lcd_putc(recibido);
recibido='\0';
delay_ms(100); }}
if(recibido=='A'){if(recibido!='\0'){
LCD_GOTOXY(1,2);
lcd_putc(recibido);
recibido='\0';
delay_ms(100); }}
if(recibido=='B'){if(recibido!='\0'){
LCD_GOTOXY(1,2);
lcd_putc(recibido);
recibido='\0';
delay_ms(100); } }
if(recibido=='C'){if(recibido!='\0'){
LCD_GOTOXY(1,2);
lcd_putc(recibido);
recibido='\0';
delay_ms(100); }}
if(recibido=='D'){if(recibido!='\0'){
LCD_GOTOXY(1,2);
lcd_putc(recibido);
recibido='\0';
delay_ms(100); }}}
//FUNCION PRINCIPAL
void main(){ set_tris_c(0b10000011);
lcd_init();//iniciar LCD
enable_interrupts(INT_RDA);//Interrupcion
por serial
enable_interrupts(GLOBAL);//Interrupciones
como globales
while(true){
recibir();
}
}
32
Ilustración 42: Tecla enviada
Ilustración 43: Tecla Recibida

Diseñar un sistema de control mediante Bluetooth, el cuál conste de dos nodos, uno que se
encargue de la toma de datos, y otro que contenga los actuadores. El primero debe tener dos
sensores, uno de temperatura, y otro de distancia. El segundo nodo debe tener dos motores,
un servo y uno DC, la condición es que se deben realizar dos controles, uno discreto y otro
continuo, de cada motor con cada sensor.
Emisor
#include <LiquidCrystal.h>
#include <Keypad.h> //Defenimos las librerias a utilizar en este caso la del teclado, la del lcd, y
la del servo
#include <NewPing.h>
#define TRIGGER_PIN 13
#define ECHO_PIN 12 // Pines del sensor de distancia y distancia maxima
#define MAX_DISTANCE 200
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // Defino la clase del

ultrasonico
AMBATO-ECUADOR
const int rs = A0, en = A1, d4 = A2, d5 = A3, d6 = A4, d7 = A5;

LiquidCrystal lcd(rs, en, d4, d5, d6, d7); // Pines del LCD
const byte rowsCount = 4;

const byte columsCount = 4; / filas y columnas del telcado
char keys[rowsCount][columsCount] = {
{ '7','8','9', 'A' },
{ '4','5','6', 'B' }, /Distribucion del teclado
{ '1','2','3', 'C' },
{ '#','0','*', 'D' }
};
const byte rowPins[rowsCount] = { 22, 23, 24, 25 }; ///Pines de las filas y columnas del telcado
const byte columnPins[columsCount] = { 26, 27, 28, 29 };
Keypad keypad = Keypad(makeKeymap(keys), rowPins, columnPins, rowsCount, columsCount);

//clase del teclado
int temp;
float temp2;
float volt;
int adc;
int pinLM35 = 6; /VARIABLES QUE SE EMPLEAN
char aux;
int dist;
float dist2;
char key;
void setup() {
lcd.begin(16,2); // Tamñao del LCD
lcd.print("1 Control Temp");
lcd.setCursor(0,1); //Comando para cambio de Fila en LCD
lcd.print("0 Control Dist");
Serial.begin(9600); //Velocidad de la Comunicacion Serial
}
void loop() {
key=keypad.getKey(); //Tomar un dato del teclado
if(key=='1'){
aux= '1';
while(aux == '1') {
opcion_A();
if(key=keypad.getKey()){ //Ejecuta la opcion A hasta presionar otra tecla
aux ='0';
}
}
AMBATO-ECUADOR
}
if(key=='0'){
aux='0';
while( aux == '0'){
opcion_B();
if(key = keypad.getKey()){ //Ejecuta la opcion B hasta presionar otra tecla
aux = '1';
}
}
}
void opcion_A(){ //lectura de temperatura
lcd.setCursor(0,0);
lcd.print("Control Tempe");
adc=analogRead(pinLM35);
lcd.setCursor(0,1);
lcd.print("CD:");
lcd.print(adc);
temp=(5.0 * adc * 100.0)/1024.0;
temp2=(5.0 * adc * 100.0)/1024.0;
lcd.print("T:");
lcd.print(temp);
volt=temp2/100;
lcd.print("V:");
lcd.print(volt);
Serial.print("1");
Serial.print("-"); //Envia por BT "1-"temperatura""
Serial.print(temp);
Serial.println();
lcd.setCursor(0,0);
lcd.print("Control Tempe");
delay(1000);
lcd.clear();
}
void opcion_B(){ //Lectura de Distancia
// Obtener medicion de tiempo de viaje del sonido y guardar en variable uS

lcd.setCursor(0,0);
lcd.print("ControlDistancia");
lcd.setCursor(0,1);
AMBATO-ECUADOR
lcd.print("Dist:");
int uS = sonar.ping_median();
dist = uS / US_ROUNDTRIP_CM;
dist2 = uS / US_ROUNDTRIP_CM;
lcd.print(dist2);
Serial.print("0");
Serial.print("-"); //Envia por BT "1-"temperatura""
Serial.print(dist);
Serial.println();
delay(1000);
lcd.clear();
}
Receptor
#include <LiquidCrystal.h> //Librerias del LCD
#define DEBUG(a) Serial.println(a); //Clase para obtener un valor String desde el puerto Serie
#include <Servo.h> //Libreria del Servo

LiquidCrystal lcd(rs, en, d4, d5, d6, d7); // Pines del Teclado
const int pinENA = 6; //Pines del driver de motor

const int pinIN1 = 5;
int a;
int b; // variables Auxiliares
int c;
const int speed1 = 0; //Variables para PWM del motor

const int speed2 = 255;
Servo servoMotor; //Variable del Servo
void setup(){
lcd.begin(16,2); //Dimensiones del LCD

lcd.print("Esperando Orden");
pinMode(pinIN1, OUTPUT); //definir los pines como salida
pinMode(pinIN2, OUTPUT);
pinMode(pinENA, OUTPUT);
servoMotor.attach(9); //Pin 9 para servo motor PWM
Serial.begin(9600); //Velocidad de Comunicacion

AMBATO-ECUADOR
void loop() {
if (Serial.available() > 0){ //Verifica si hay un dato en el puerto serie
lcd.setCursor(0 , 0);
String str = Serial.readStringUntil('\n'); //Transforma el dato del puerto serie en string
DEBUG(str);
int parte1 = getValue(str,'-',0).toInt(); // Devuelve un entero separado por "-"
int parte2 = getValue(str,'-',1).toInt(); // Devuelve un entero separado por "-"
if(parte1 == 1){ // si el primer dato es un "1" ejecuta lo siguiente:

// lcd.clear();
lcd.print("Motor DC Temp");
lcd.setCursor(0,1);
lcd.print("PWM DEL MOTOR");
if (parte2 <= 30) { //si la TEMP es menor a 30coloca el DC en 0

digitalWrite(pinIN1, HIGH);
digitalWrite(pinIN2, LOW);
analogWrite(pinENA, speed1);
lcd.print("DC:");
lcd.print("0");
lcd.print("%");
if ( 30 < parte2 <= 80) { //Incremento continuo 0 a 100 del DC si la TEMP esta entre 30 y
80
a= parte2-30;
b=(a*100)/50; // porcentaje //Aplicamos reglas de tres
c=(b*255)/100; // pulsasiones (0-255)
analogWrite(pinENA, c);
lcd.print("DC:");
lcd.print(b);
lcd.print("%");
AMBATO-ECUADOR
}
if( parte2 > 80){ //si la TEMP es mayor a 80 coloca el DC en 0
lcd.print("DC:");
lcd.print("0");
lcd.print("%");
}
}
if(parte1 == 0){ //SI la primera parte del dato es 0, se ejecuta lo siguiente con el servo
digitalWrite(pinIN2, LOW); //Desabilita el motor DC
// lcd.clear();
lcd.setCursor(0,0);
lcd.print("ServoMotor DISTA");
// lcd.setCursor(0,1);
//lcd.print("MOV DEL SERVO");
if( parte2 <= 25){ //Si la distancia es menor a 25, coloca el servo a 45 grados
servoMotor.write(45);
lcd.setCursor(0,1);
lcd.print("SERVO 045°");
else if( parte2 <= 50){ //Si la distancia es menor a 50, coloca el servo a 90 grados
lcd.setCursor(0,1);
else if(parte2 <= 75){ //Si la distancia es menor a 75, coloca el servo a 135 grados
lcd.setCursor(0,1);
}
else if(parte2 <= 100){ //Si la distancia es menor a 100, coloca el servo a 180 grados
AMBATO-ECUADOR
lcd.setCursor(0,1);
else if( parte2 >= 101){ //Si la distancia es mayor a 101, coloca el servo a 60 grados
lcd.setCursor(0,1);
}
delay(500);
}
String getValue(String data, char separator, int index)

{
int found = 0;
int strIndex[] = {0, -1};
int maxIndex = data.length()-1;
for(int i=0; i<=maxIndex && found<=index; i++){

if(data.charAt(i)==separator || i==maxIndex){
found++;
strIndex[0] = strIndex[1]+1;
strIndex[1] = (i == maxIndex) ? i+1 : i;
}
}
return found>index ? data.substring(strIndex[0], strIndex[1]) : "";

}
AMBATO-ECUADOR
Ilustración 9 Funcionamiento del Ejercicio 1

AMBATO-ECUADOR
Diseñar un sistema de control mediante Bluetooth, el cuál conste de dos nodos, uno
que se encargue de la toma de datos, y otro que contenga los actuadores. El primero
debe tener dos sensores de distancia, del cual se obtendrá el promedio y se
establecerá un control discreto o continuo para un motor DC. En los dos LCD se debe
mostrar la misma información.
Emisor
1. #include <LiquidCrystal.h>
2. #include <Keypad.h>
3.
4. const int rs = A0, en = A1, d4 = A2, d5 = A3, d6 = A4, d7 = A5;
5. LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
6.
7. const byte rowsCount = 4;
8. const byte columsCount = 4;
9.
10. char keys[rowsCount][columsCount] = {
11. { '7','8','9', 'A' },
12. { '4','5','6', 'B' },
13. { '1','2','3', 'C' },
14. { '#','0','*', 'D' }
15. };
16.
17. const byte rowPins[rowsCount] = { 22, 23, 24, 25 };
18. const byte columnPins[columsCount] = { 26, 27, 28, 29 };
19.
20. Keypad keypad = Keypad(makeKeymap(keys), rowPins, columnPins, rowsCount, columsCount);
21.
22. int temp1;
23. int temp2;
24. int prom;
25. int pin1 = 8;
26. int pin2 = 9;
27. char key;
28. char aux;
29. int gra;
30.
31. void setup() {
32. lcd.begin(16,2);
33. lcd.print("Modo Trabajo");
34. lcd.setCursor(0,1);
35. lcd.print("1MID-2MIC-A:MEN");
36. Serial.begin(9600);
37. }
38.
39. void loop() {
40.
42. lcd.print("S1:");
43. temp1 = analogRead(pin1);
44. temp1 = (5.0 * temp1 * 100.0)/1024.0;
45. lcd.print(temp1);
AMBATO-ECUADOR

48. temp2 = (5.0 * temp2 * 100.0)/1024.0;
50. prom=(temp1+temp2)/2;
51. lcd.print("P:");
52. lcd.print(prom);
53.
54. key=keypad.getKey();
55.
56. if(key=='1'){
57. aux= '1';
58. while(aux == '1') {
62. temp1 = (5.0 * temp1 * 100.0)/1024.0;
66. temp2 = (5.0 * temp2 * 100.0)/1024.0;
71. opcion_A();
72. if(key=keypad.getKey()){
73. aux ='0';
74. }
75. }
76.
77. }
78.
79.
80. if(key=='2'){
81. aux='2';
82. while( aux == '2'){
86. temp1 = (5.0 * temp1 * 100.0)/1024.0;
90. temp2 = (5.0 * temp2 * 100.0)/1024.0;
95. opcion_B();
96. if(key = keypad.getKey()){
97. aux = '1';
98. }
99. }
100. }
101.
102. if(key=='A'){
103. aux= 'A';
104. while(aux == 'A') {
105. opcion_C();
106. if(key=keypad.getKey()){
107. aux ='0';
108. }
109. }
110. }
111. }
AMBATO-ECUADOR
112. void opcion_A(){

113.
115. lcd.print("MID-");
116. Serial.print("1");
117. Serial.print("-");
118. Serial.print(prom);
119. Serial.println();
120.
121. if (prom > 90) {
122.
123. gra = 0;
124. int dc = 0;
125. lcd.print(gra);
126. lcd.print(" G");
127.
128. }
129.
130. if ( prom >= 30 && prom <= 90){
131.
132. int a = prom;
133.
134. if ( a >= 30 ) {
135.
136. gra = 0;
139.
140.
141. }
142.
143. if ( a > 30 && a <= 40 ) {
144.
145. gra = 30;
148.
149.
150. }
151. if ( a >= 41 && a <= 50 ) {
152.
153. gra = 60;
156.
157. }
158. if ( a >= 51 && a <= 60 ) {
159.
160. gra = 90;
163.
164.
165. }
166.
167. if ( a >= 61 && a <= 70 ) {
168.
169. gra = 120;
172.
173.
174. }
175.
176. if ( a >= 71 && a <= 80 ) {
AMBATO-ECUADOR
177.
178. gra = 150;
181.
182.
183. }
184. if ( a >= 81 && a <= 90 ) {
185.
186. gra = 180;
189.
190.
191. }
192.
193. }
194. delay(1000);
195. lcd.clear();
196. }
197.
198.
199.
200. void opcion_B(){
201.
203. lcd.print("MIC-");
208.
209. if ( prom >= 30 && prom <= 90){
210.
211. int a= prom-30;
212. int b=(a*180)/60; // grados
213.
214. gra = b;
217.
218.
219. if (prom > 90) {
220.
221. gra = 0;
224. }
225.
226. if (prom < 30) {
227.
228. gra = 0;
231.
232. }
233. }
234.
235. delay(1000);
236. lcd.clear();
237. }
238.
239. void opcion_C(){
240.
241. lcd.clear();
AMBATO-ECUADOR
243. lcd.print("MENU PRINCIPAL");
248. }
RECEPTOR
#include <LiquidCrystal.h>
#define DEBUG(a) Serial.println(a);

LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
const int pinENA = 6;

int a;
int b;
int c;
int pwm;

void setup(){
lcd.begin(16,2);
lcd.print("Esperando Orden");
pinMode(pinENA, OUTPUT);
Serial.begin(9600);
}
void loop() {
if (Serial.available() > 0){
lcd.setCursor(0 , 0);
String str = Serial.readStringUntil('\n');
DEBUG(str);
int parte1 = getValue(str,'-',0).toInt();
int dist1 = getValue(str,'-',1).toInt();

int dist2 = getValue(str,'-',2).toInt();
AMBATO-ECUADOR
int prom = (dist1+dist2)/2;

//Lectura de temperatura
if(parte1 == 2){
lcd.setCursor(0,0);
lcd.print("S1:");
lcd.print(dist1);
lcd.print("S2:");
lcd.print(dist2);
lcd.print("P:");
lcd.print(prom);
lcd.setCursor(0,1);
lcd.print("MIC-");
if (prom > 80) {
pwm = 0;
int dc = 0;
lcd.print(pwm);
lcd.print("%");
analogWrite(pinENA, pwm);
if (prom < 30) {
pwm = 0;
int dc = 0;
lcd.print(pwm);
lcd.print("%");
analogWrite(pinENA, pwm);
if ( prom >= 30 && prom <= 80){
a= prom-30;
b=(a*100)/50; // porcentaje
c=(b*255)/100; // pulsasiones (0-255)
pwm = b;
AMBATO-ECUADOR
lcd.print(pwm);
lcd.print("%");
analogWrite(pinENA, c);
}
}
if (parte1 == 1){
lcd.setCursor(0,0);
lcd.print("S1:");
lcd.print(dist1);
lcd.print("S2:");
lcd.print(dist2);
lcd.print("P:");
lcd.print(prom);
lcd.setCursor(0,1);
lcd.print("MID-");
if (prom > 80) {
pwm = 0;
int dc = 0;
lcd.print(pwm);
lcd.print("%");
analogWrite(pinENA, dc);
if (prom < 30) {
pwm = 0;
int dc = 0;
lcd.print(pwm);
lcd.print("%");
analogWrite(pinENA, dc);
if ( prom >= 30 && prom <= 80){
int a = prom - 30;
if ( a >= 0 && a <= 10 ) {

AMBATO-ECUADOR
pwm = 20;
int dc = 51;
lcd.print(pwm);
lcd.print("%");
if ( a >= 11 && a <= 20 ) {
pwm = 40;
int dc = 102;
lcd.print(pwm);
lcd.print("%");
}
if ( a >= 21 && a <= 30 ) {
pwm = 60;
int dc = 153;
lcd.print(pwm);
lcd.print("%");
}
if ( a >= 30 && a <= 40 ) {
pwm = 80;
int dc = 204;
lcd.print(pwm);
lcd.print("%");
if ( a >= 41 && a <= 50 ) {
pwm = 100;
int dc = 255;
lcd.print(pwm);
lcd.print("%");
if(parte1 == 3){
lcd.clear();
AMBATO-ECUADOR
lcd.setCursor(0,0);
lcd.print("MENU PRINCIPAL");
}
delay(500);
}
}
String getValue(String data, char separator, int index)
{
int found = 0;
int strIndex[] = {0, -1};
int maxIndex = data.length()-1;
for(int i=0; i<=maxIndex && found<=index; i++){

if(data.charAt(i)==separator || i==maxIndex){
found++;
strIndex[0] = strIndex[1]+1;
strIndex[1] = (i == maxIndex) ? i+1 : i;
}
}
return found>index ? data.substring(strIndex[0], strIndex[1]) : "";

}
Ilustración 12 Funcionamiento Ejercicio 2

Elaborado por: Bayas Juan, Carrera Jazmín, Chuquitarco Wilmer
AMBATO-ECUADOR

AMBATO-ECUADOR

AMBATO-ECUADOR
EJERCICIO PROPUESTO 3 USANDO PICs

Diseñar un sistema de control mediante Bluetooth, el cuál conste de dos nodos, uno que se encargue
de la toma de datos, y otro que contenga los actuadores. El primero debe tener dos sensores de
temperatura, del cual se obtendrá el promedio y se establecerá un control discreto o continuo para
un servo motor. En los dos LCD se debe mostrar la misma información.
CODIGO DEL TRANSMISOR
#INCLUDE <16F887.H>
#USE DELAY(CLOCK=4M)
#fuses INTRC, MCLR=0
AMBATO-ECUADOR
#DEFINE USE_PORTB_KBD //Por defecto el teclado se conecta al puerto D,

#INCLUDE <LCD.C>
#INCLUDE <KBD4x4.C> //Incluir en el encabezado el driver para
#use standard_io(b)
#use standard_io(c)
#define KEYHIT_DELAY 200 //Tiempo de espera del teclado en milisegundos
#use RS232(baud=9600, xmit=PIN_C6, rcv=PIN_C7, bits=8, parity=N)
#byte PORTB= 6
#BYTE PORTD= 8
#define trig pin_E1
#define echo pin_E0
//#define motor pin_E2
#define trig1 pin_C1

#define echo1 pin_C0
//#define motor1 pin_C2
#USE standard_io(e)
#USE standard_io(c)
#BYTE WPUB= 0x95
#BYTE OPTION_REG = 0x81
int16 tiempo;
float distancia;
int16 tiempo1;
float distancia1;
char k;
char tecla(void)
{
char c;
do{ //espera hasta que se presione una tecla
c=kbd_getc(); //Captura valor del teclado
}
while(c=='\0');
return(c);
}
char tecla_time(void) {
char c='\0';
timeout=0;
while(c=='\0' && (++timeout< (KEYHIT_DELAY*100)))
{
delay_us(10);
}
AMBATO-ECUADOR
return(c);
}
VOID MAIN()
{
CHAR K;
CHAR X;
CHAR Y;
CHAR Z;
port_b_pullups (0xFF); //Utiliza las resistencias PULL UP internas del puerto B
SET_TRIS_B(0);
//SET_TRIS_C(0); //Puerto C como Salida
setup_adc_ports(sAN0); //Pongo RA0 como analogo
setup_adc(adc_clock_internal); //Selecciono reloj interno para conversion
LCD_INIT(); //Inicializar el driver del lcd
KBD_INIT(); //Inicializar el driver del teclado
LCD_PUTC("\f"); //Limpia el LCD
LCD_GOTOXY(1,1); //Ubica el cursor del LCD
LCD_PUTC("MODO OPERACION");
LCD_PUTC("1:MID,2:MIC,A:MENU");
WHILE(TRUE)
{
k=tecla_time();
if(k=='A'||X=='A'){
if(k=='A'){
putchar(164);
delay_ms(50);
}
lcd_putc("\f");
setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
output_high(trig);
delay_us(20);
output_low(trig);
while(!input(echo))
{}
set_timer1(0);
while(input(echo))
{}
tiempo=get_timer1();
distancia=tiempo*0.14;
int n=distancia;
set_timer1(0);
delay_ms(450);
//////////////////
output_high(trig1);
delay_us(20);
AMBATO-ECUADOR
output_low(trig1);
while(!input(echo1))
{}
set_timer1(0);
while(input(echo1))
{}
tiempo1=get_timer1();
distancia1=tiempo1*0.14;
int n1=distancia1;
set_timer1(0);
delay_ms(450);
int promedio1=(n+n1)/2;
putchar(promedio1);
lcd_gotoxy(1,1);
printf(lcd_putc,"S1:%u",n);
lcd_gotoxy(5,1);
printf(lcd_putc,"S2:%u",n1);
lcd_gotoxy(8,1);
printf(lcd_putc,"P:%u",promedio1);
delay_ms(300);
X='A';
Y='F';
Z='F';
}
if(k=='B'||Y=='B'){
if(k=='B'){
putchar(165);
delay_ms(50);
}
lcd_putc("\f");
output_high(trig);
delay_us(20);
output_low(trig);
while(!input(echo))
{}
set_timer1(0);
while(input(echo))
{}
int n=distancia;
lcd_gotoxy(1,1);
printf(lcd_putc, "S1:%u",n);
set_timer1(0);
delay_ms(450);
//////////////////////
output_high(trig1);
delay_us(20);
AMBATO-ECUADOR
output_low(trig1);
while(!input(echo1))
{}
set_timer1(0);
while(input(echo1))
{}
tiempo1=get_timer1();
distancia1=tiempo1*0.14;
int n1=distancia1;
lcd_gotoxy(5,1);
printf(lcd_putc, "S2:%u",n1);
set_timer1(0);
delay_ms(450);
int promedio2=(n+n1)/2;
putchar(promedio2);
lcd_gotoxy(8,1);
printf(lcd_putc, "P:%u",promedio2);
delay_ms(300);
Y='B';
X='F';
Z='F';
}
if(k=='#'||Z=='#'){
LCD_PUTC("MODO OPERACION");
LCD_PUTC("1:MID,2:MIC,A:MENU ");
delay_ms(300);
int cero=166;
putchar(cero);
Z='#';
Y='F';
X='F';
}
}
}
CODIGO DEL RECEPTOR
#INCLUDE <16F887.H>
//#DEFINE USE_PORTB_LCD TRUE
#INCLUDE <LCD.C>
#INCLUDE <STDLIB.H>
AMBATO-ECUADOR
int valor;
#int_RDA
void RDA_isr(){
valor=getc();
}
void SONIC(){
while(TRUE){
if(valor>0){
lcd_putc("\f");
int pwm2=valor*50;
int porcen1=100;
lcd_gotoxy(1,1);
printf(lcd_putc,"Motor2 ON al:%u",porcen1);
lcd_gotoxy(1,2);
printf(lcd_putc, "Distancia=%u",valor);
delay_ms(100);
}
if(valor==165) break;
}
}
void SONIC1(){
while(TRUE){
if(valor>0){
lcd_putc("\f");
int pwm1=valor*50;
int porcen1=100;
lcd_gotoxy(1,1);
lcd_gotoxy(1,2);
delay_ms(100);
}
if(valor==164) break;
}
}
void APAGAR(){
while(TRUE){
printf(lcd_putc, "\fMOTORES OFF");
set_pwm2_duty(0);
delay_ms(300);
if(valor==164 || valor==165) break;
}
AMBATO-ECUADOR
void main()
{
lcd_init();
enable_interrupts(INT_RDA);
SETUP_CCP2(CCP_PWM);
setup_timer_2(t2_div_by_4,250,1);
lcd_gotoxy(1,1); //mensaje de inicio

lcd_putc("SENSORES APAGADOS");
lcd_gotoxy(1,2);
lcd_putc("SENSOR[1,2]: OFF");
while(TRUE){
if(kbhit())
valor=getc();
set_pwm2_duty(0);
if(valor==164)
SONIC();
if(valor==165)
SONIC1();
if(valor==166)
APAGAR();
}
}
Ilustración 19 Funcionamiento del Ejercicio 3 con PIC

Elaborado por: Bayas Juan, Carrera Jazmín, Chuquitarco Wilmer
AMBATO-ECUADOR
EJERCICIO PROPUESTO 4 USANDO PICs

Diseñar un sistema de control mediante Bluetooth, el cuál conste de dos nodos, uno que se encargue
de la toma de datos, y otro que contenga los actuadores. El primero debe tener dos sensores, uno de
temperatura, y otro de distancia. El segundo nodo debe tener dos motores, un servo y uno DC, la
condición es que se deben realizar dos controles, uno discreto y otro continuo, de cada motor con
cada sensor.
CODIGO DEL TRANSMISOR
AMBATO-ECUADOR
#INCLUDE <16F887.H>
#device adc=10
#fuses INTRC_IO, MCLR=0
#INCLUDE <LCD.C>
#INCLUDE <KBD4x4.C> //Incluir en el encabezado el driver para
#use standard_io(b)
#use standard_io(c)
#define KEYHIT_DELAY 200 //Tiempo de espera del teclado en milisegundos
#byte PORTB= 6
#BYTE PORTA= 5
#BYTE PORTD= 8
#define trig pin_E1
#define echo pin_E0
#define motor pin_E2
#USE standard_io(e)
#USE standard_io(c)
#BYTE WPUB= 0x95
#BYTE OPTION_REG = 0x81
int16 tiempo;
float distancia;
char k;
float bits; //Variable almacena los bits

int tem; //Almacena la temperatura
float volt;
/*FUNCION TECLA*/
//Funcion encargada de esperar a que se presione una tecla
char tecla(void)
{
char c;
do{ //espera hasta que se presione una tecla
}
while(c=='\0');
return(c);
}
/*FUNCION TECLA CON TIMER*/
// Pregunta por una Tecla por un tiempo, si no hay actividad, deja de preguntar
// y deja que el PIC continue con su trabajo
char tecla_time(void) {
char c='\0';
timeout=0;
AMBATO-ECUADOR
while(c=='\0' && (++timeout< (KEYHIT_DELAY*100)))

{
delay_us(10);
}
return(c);
}
/*PROGRAMA PRINCIPAL*/
VOID MAIN()
{
CHAR K;
CHAR X;
CHAR Y;
CHAR Z;
port_b_pullups (0xFF); //Utiliza las resistencias PULL UP internas del puerto B
set_tris_a(0b00000001); //Pongo el RA0 como entrada
SET_TRIS_B(0);
//SET_TRIS_C(0); //Puerto C como Salida
setup_adc_ports(sAN0); //Pongo RA0 como analogo
setup_adc(adc_clock_internal); //Selecciono reloj interno para conversion
LCD_INIT(); //Inicializar el driver del lcd
KBD_INIT(); //Inicializar el driver del teclado
LCD_PUTC("ESCOJA UN SENSOR");
LCD_PUTC("A: LM35 B:ULTRA");
WHILE(TRUE)
{
k=tecla_time();
if(k=='A'||X=='A'){
if(k=='A'){
putchar(164);
delay_ms(50);
}
LCD_GOTOXY(1,1);
set_adc_channel(0); //Selecciono el canal 0 (RA0)
delay_ms(1); //llamo retardo de 1 ms
bits=read_adc(); //Guarde el dato del LM en tempe
tem=bits*0.4882; //Conversion de bits a temperatura
volt=bits*5/1023; // conversion para el voltaje
LCD_PUTC("\f");
LCD_GOTOXY(1,1);
LCD_PUTC("SENSOR LM35 ");
printf(lcd_putc,"A:%3.0f",bits);
printf(lcd_putc,"T:%u",tem); //Muestra el valor numerico de la conversionconversion
AMBATO-ECUADOR

printf(lcd_putc,"V:%3.2f",volt); //Muestra el valor numerico de la conversionconversion
int env=tem;
putchar(env);
X='A';
Y='F';
Z='F';
}
if(k=='B'||Y=='B'){
if(k=='B'){
putchar(165);
delay_ms(50);
}
output_high(trig);
delay_us(20);
output_low(trig);
while(!input(echo))
{}
set_timer1(0);
while(input(echo))
{}
int n=distancia;
LCD_PUTC("S: ULTRASONICO");
printf(LCD_PUTC,"DISTANCIA:%u",n);
set_timer1(0);
delay_ms(450);
putchar(n);
Y='B';
X='F';
Z='F';
}
if(k=='#'||Z=='#'){
LCD_PUTC("ESCOJA UN SENSOR");
LCD_PUTC("A: LM35 B:ULTRA");
int cero=166;
putchar(cero);
delay_ms(300);
Z='#';
Y='F';
X='F';
AMBATO-ECUADOR
}
}
}
CODIGO DEL RECEPTOR

#INCLUDE <16F887.H>
#device adc=10
#fuses INTRC_IO, MCLR=0
#use standard_io(b)
//#DEFINE USE_PORTB_LCD TRUE

#INCLUDE <LCD.C>
#INCLUDE <STDLIB.H>
int valor;
#int_RDA
void RDA_isr(){
valor=getc();
}
void LM35(){
set_pwm1_duty(0);
while(TRUE){
if(valor>50 && valor<=80){
lcd_putc("\f");
int v=valor;
int pwm=(v-50)*8.3;
int porcen=pwm*0.402;
set_pwm2_duty(pwm);
lcd_gotoxy(1,1);
printf(lcd_putc,"DUTY CYCLE:%d",porcen);
lcd_gotoxy(1,2);
printf(lcd_putc, "MOTOR1:ON TEM:%u",v);
delay_ms(300);
}
if(valor>80 && valor<150){
int pwm1=249;
int v2=valor;
set_pwm1_duty(0);
lcd_putc("\f");
lcd_gotoxy(1,1);
printf(lcd_putc,"DUTY CYCLE:%d",100);
lcd_gotoxy(1,2);
printf(lcd_putc,"MOTOR1:ON T:%d",v2);
delay_ms(300);
AMBATO-ECUADOR
}
if(valor<=50){
lcd_putc("\f"); //Limpia el LCD
set_pwm2_duty(0);
set_pwm1_duty(0);
lcd_gotoxy(1,1); //Ubica el cursor del LCD
lcd_putc("MOTOR1 OFF");
printf(lcd_putc,"TEMPERATURA=%u",valor);
delay_ms(300);
}
}
}
void SONIC(){
set_pwm2_duty(0);
while(TRUE){
if(valor<=15){
lcd_putc("\f"); //Limpia el LCD
set_pwm1_duty(0);
output_high(PIN_B0); // ESCRIBE EL 9 EN BINARIO DE 8 BITS (enciende motor y led rojo)
output_low(PIN_B1); // ESCRIBE EL 9 EN BINARIO DE 8 BITS (enciende motor y led rojo)
delay_ms(20);
lcd_putc("MOTOR2 GIRO 180");
printf(lcd_putc,"DISTANCIA:=%u",valor);
delay_ms(300);
}
if(valor>15 && valor<=30){
int dis=(valor-15)*16.6;
int porcen1=180;
set_pwm1_duty(dis);
output_high(PIN_B1); // ESCRIBE EL 9 EN BINARIO DE 8 BITS (enciende motor y led rojo)
output_low(PIN_B0); // ESCRIBE EL 9 EN BINARIO DE 8 BITS (enciende motor y led rojo)
delay_ms(20);
lcd_putc("\f");
lcd_gotoxy(1,1);
printf(lcd_putc,"Motor2 GIRO:%u",porcen1);
lcd_gotoxy(1,2);
delay_ms(300);
}
if(valor>30){
int dis1=249;
int porcen2=100;
AMBATO-ECUADOR
set_pwm1_duty(dis1);
lcd_putc("\f");
lcd_gotoxy(1,1);
lcd_gotoxy(1,2);
delay_ms(300);
}
}
}
void APAGAR(){
while(TRUE){
if(valor>0){
set_pwm2_duty(0);
set_pwm1_duty(0);
lcd_putc("\f");
lcd_gotoxy(1,1);
lcd_putc("MOTORES APAGADOS");
delay_ms(300);
}
}
}
void main()
{
lcd_init();
enable_interrupts(INT_RDA); //iniciamos la interrupcion RDA
enable_interrupts(GLOBAL); //iniciamos las interrupciones globales
SETUP_CCP1(CCP_PWM); //habilitamos los puertos PWM
SETUP_CCP2(CCP_PWM);
setup_timer_2(t2_div_by_4,249,1); //establecemos los parametros del timer 2
lcd_gotoxy(1,1); //mensaje de inicio

lcd_putc("MOTORES APAGADOS");
lcd_gotoxy(1,2);
lcd_putc("MOTOR[1,2]: OFF");
set_pwm2_duty(0);
set_pwm1_duty(0);
set_tris_b(0x00);
while(TRUE){ //bucle infinito
if(kbhit())
valor=getc();
if(valor==164)
LM35();
AMBATO-ECUADOR
if(valor==165)
SONIC();
if(valor==166)
APAGAR();
}
}
RESULTADO
Ilustración 22 Esquema final del Ejercicio 4 con PIC.
Ilustración 23 Menú ye inicio de la simulación.

AMBATO-ECUADOR
Ilustración 24 Funcionamiento del sensor LM35 y Motor 1 con la tecla A..
Ilustración 25 Funcionamiento del sensor ultrasónico y el motor 2 con la tecla B..

AMBATO-ECUADOR
Ilustración 26 Regreso al menú principal con #.

AMBATO-ECUADOR
Segundo Parcial
10. Creación de Proyectos

Ejercicio en clase 1
TEMA
Multiplexor
OBJETIVOS
Objetivo General
✓ Desarrollar un medio sumador utilizando programación en VHDL
Objetivos Específicos
✓ Desarrollar mediante la tabla de verdad un medio sumador
✓ Desarrollar un medio sumador mediante la ecuación de salida
✓ Desarrollar un medio sumador mediante su circuito interno
MATERIALES Y EQUIPOS
✓ Computadora
✓ ISE design suitei
DESARROLLO
1. library IEEE;
2. use IEEE.STD_LOGIC_1164.ALL;
3.
4. entity semisumador is
5. Port ( E : in STD_LOGIC_VECTOR(1 DOWNTO 0);
6. S : out STD_LOGIC;
7. C : out STD_LOGIC);
8. end semisumador;
9.
10. architecture Behavioral of semisumador is
11.
12. begin
13. with E select
14. S <= '0' when "00",
15. '1' when "01",
16. '1' when "10",
17. '0' when others;
18. with E select
19. C <= '0' when "00",
20. '0' when "01",
21. '0' when "10",
22. '1' when others;
23.
24.
25. end Behavioral;
Mediante ecuaciones de salida
1. library IEEE;
AMBATO-ECUADOR
3.
4. entity EcClase is
5. Port ( A : in STD_LOGIC;
6. B : in STD_LOGIC;
7. Z : out STD_LOGIC;
8. C : out STD_LOGIC);
9. end EcClase;
10.
11. architecture Behavioral of EcClase is
12.
13. begin
14. z<= (A and B);
15. c<= (A xor B);
16.
17.
18. end Behavioral;
Desarrollo mediante circuito
1. library IEEE;
3.
4. entity Mux21 is
7. S : in STD_LOGIC;
8. Z : out STD_LOGIC);
9. end Mux21;
10.
11. architecture Behavioral of Mux21 is
12. signal s0,s1:std_logic;
13. begin
14. s0<=A and(not S);
15. s1<=B and S;
16. Z<= s0 or s1;
17.
18. end Behavioral;
RESULTADOS
Resultados de circuito mediante tabla de verdad
1. LIBRARY ieee;
2. USE ieee.std_logic_1164.ALL;
3. ENTITY Testtabla IS
4. END Testtabla;
5.
6. ARCHITECTURE behavior OF Testtabla IS
7.
8. -- Component Declaration for the Unit Under Test (UUT)
9.
10. COMPONENT TablaMux
11. PORT(
12. inp : IN std_logic_vector(1 downto 0);
13. S : IN std_logic;
14. Z : OUT std_logic
15. );
16. END COMPONENT;
17.
18. --Inputs
19. signal inp : std_logic_vector(1 downto 0) := (others => '0');
20. signal S : std_logic := '0';
AMBATO-ECUADOR
21.
22. --Outputs
23. signal Z : std_logic;
24.
25. BEGIN
26.
27. -- Instantiate the Unit Under Test (UUT)
28. uut: TablaMux PORT MAP (
29. inp => inp,
30. S => S,
31. Z => Z
32. );
33. -- Stimulus process
34. stim_proc: process
35. begin
36. inp<="00"; wait for 10 ns;
40. wait;
41. end process;
42.
43. END;
Ilustración 196 Resultado Tabla de verdad
Resultado mediante circuito:
1. LIBRARY ieee; 12. PORT(

2. USE ieee.std_logic_1164.ALL; 13. A : IN std_logic;
3. 14. B : IN std_logic;
4. ENTITY TestMux21 IS 15. S : IN std_logic;
5. END TestMux21; 16. Z : OUT std_logic
6. 17. );
7. ARCHITECTURE behavior OF TestMux21 IS 18. END COMPONENT;
19.
8. 20.
9. -- 21. --Inputs
Component Declaration for the Unit U 22. signal A : std_logic := '0';
nder Test (UUT) 23. signal B : std_logic := '0';
10. 24. signal S : std_logic := '0';
11. COMPONENT Mux21 25.
AMBATO-ECUADOR
26. --Outputs 38. );

27. signal Z : std_logic; 39. -- Stimulus process
28. 40. stim_proc: process
29. 41. begin
30. BEGIN 42. --
31. hold reset state for 100 ns.
32. -- 43. wait for 10 ns;
Instantiate the Unit Under Test (UUT 44. -- insert stimulus here
) 45.
33. uut: Mux21 PORT MAP ( 46. wait;
34. A => A, 47. end process;
35. B => B, 48.
36. S => S, 49. END;
37. Z => Z
Ilustración 197 Resultado mediante circuito

AMBATO-ECUADOR
Resultados mediante ecuación de salida
1. LIBRARY ieee; 27.

2. USE ieee.std_logic_1164.ALL; 28. --
3. Instantiate the Unit Under Test (UUT
4. ENTITY simulacion IS )
5. END simulacion; 29. uut: Mux22 PORT MAP (
6. 30. I0 => I0,
7. ARCHITECTURE behavior OF simulacion I 31. I1 => I1,
S 32. S => S,
8. 33. F => F
9. COMPONENT Mux22 34. );
10. PORT( 35. -- Stimulus process
11. I0 : IN std_logic; 36. stim_proc: process
12. I1 : IN std_logic; 37. begin
13. S : IN std_logic; 38. I0 <= '1'; I1<='0';
14. F : OUT std_logic 39. S <='0'; wait for 200 ns;
15. ); 40. S <= '1'; wait for 200 ns;
16. END COMPONENT; 41.
17. 42. I0 <= '0'; I1<='1';
18. 43. S <= '1'; wait for 200 ns;
19. --Inputs 44. S <= '0'; wait for 200 ns;
20. signal I0 : std_logic := '0'; 45.
21. signal I1 : std_logic := '0'; 46.
22. signal S : std_logic := '0'; 47.
23. 48. end process;
24. --Outputs 49.
25. signal F : std_logic; 50. END;
26. BEGIN
Ilustración 198 Resultado ecuación de salida

AMBATO-ECUADOR
Ejercicios en clase 2:
TEMA
Programación y simulación de un half adder
OBJETIVOS
Objetivo General
✓ Realizar la programación y simulación de un medio sumador
✓ Desarrollar los programas mediante su tabla de verdad circuito y ecuación de salida
✓ Conocer el funcionamiento de cada entorno de ISE Design Suite
✓ Realizar las simulaciones
✓ Computadoras
✓ ISE Design Suite
DESARROLLO
Desarrollo mediante ecuación de salida
1. library IEEE;
3.
4. entity Mux22 is
5. Port ( I0,I1,S : in STD_LOGIC;
6. F : out STD_LOGIC);
7. end Mux22;
8.
9.
11.
12. begin
13.
14. F <= I1 when (S = '1') else I0;
15.
16. end Behavioral;
Desarrollo mediante tabla de verdad
1. library IEEE; 16. z<= '0';

2. use IEEE.STD_LOGIC_1164.ALL; 17. when "01"=>
3. entity TablaMux is 18. z<='0';
4. Port ( inp: in STD_LOGIC_VECTOR( 19. when "10"=>
1 downto 0); 20. z<='1';
5. S : in STD_LOGIC; 21. when others =>
6. Z : out STD_LOGIC); 22. z<='1';
7. end TablaMux; 23. end case;
8. 24. else if s='1' then
9. architecture Behavioral of TablaMux i 25. case inp is
s 26. when "00"=>
10. begin 27. z<='0';
11. p_mux: process (s,inp) 28. when "01"=>
12. begin 29. z<='1';
13. if s='0' then 30. when "10"=>
14. case inp is 31. z<='0';
15. when "00"=> 32. when others=>
AMBATO-ECUADOR
33. z<='1'; 36. end if;

34. end case; 37. end process;
35. end if; 38. end Behavioral
Desarrollo mediante señales
1. library IEEE;
3. entity Mux21 is
6. S : in STD_LOGIC;
8. end Mux21;
9.
11. signal s0,s1:std_logic;
12. begin
13. s0<=A and(not S);
14. s1<=B and S;
15. Z<= s0 or s1;
16.
17. end Behavioral;
RESULTADOS
Resultados ecuación de salida
1. LIBRARY ieee; 25. signal F : std_logic;

2. 26.
3. USE ieee.std_logic_1164.ALL; 27. BEGIN
4. ENTITY simulacion IS 28.
5. END simulacion; 29. --
6. Instantiate the Unit Under Test (UUT
7. ARCHITECTURE behavior OF simulacion I )
S 30. uut: Mux22 PORT MAP (
8. 31. I0 => I0,
9. COMPONENT Mux22 32. I1 => I1,
10. PORT( 33. S => S,
11. I0 : IN std_logic; 34. F => F
12. I1 : IN std_logic; 35. );
13. S : IN std_logic; 36. stim_proc: process
14. F : OUT std_logic 37. begin
15. ); 38. I0 <= '1'; I1<='0';
16. END COMPONENT; 39. S <='0'; wait for 200 ns;
17. 40. S <='1'; wait for 200 ns;
18. 41.
19. --Inputs 42. I0 <= '0'; I1<='1';
20. signal I0 : std_logic := '0'; 43. S <='1'; wait for 200 ns;
21. signal I1 : std_logic := '0'; 44. S <= '0'; wait for 200 ns;
22. signal S : std_logic := '0'; 45. end process;
23. 46.
24. --Outputs 47. END;
48.
AMBATO-ECUADOR
Ilustración 199 Resultado Ecuacion
Resultados tabla de verdad
1. LIBRARY ieee; 23. --Outputs

2. USE ieee.std_logic_1164.ALL; 24. signal Z : std_logic;
3. ENTITY Testtabla IS 25. BEGIN
4. END Testtabla; 26.
5. 27. --
6. ARCHITECTURE behavior OF Testtabla IS Instantiate the Unit Under Test (UUT
)
7. 28. uut: TablaMux PORT MAP (
8. -- 29. inp => inp,
Component Declaration for the Unit U 30. S => S,
nder Test (UUT) 31. Z => Z
9. 32. );
10. COMPONENT TablaMux 33.
11. PORT( 34.
12. inp : IN std_logic_vector(1 35.
downto 0); 36. -- Stimulus process
13. S : IN std_logic; 37. stim_proc: process
14. Z : OUT std_logic 38. begin
15. ); 39. inp<="00"; wait for 10 ns;
16. END COMPONENT; 40. inp<="01"; wait for 10 ns;
17. 41. inp<="10"; wait for 10 ns;
18. 42. inp<="11"; wait for 10 ns;
19. --Inputs 43. wait;
20. signal inp : std_logic_vector(1 do 44. end process;
wnto 0) := (others => '0'); 45.
21. signal S : std_logic := '0'; 46. END;
22.
Ilustración 200 Resultado tabla de verdad

AMBATO-ECUADOR
Resultado señales
1. LIBRARY ieee;
3. ENTITY TestMux21 IS
4. END TestMux21;
5.
6. ARCHITECTURE behavior OF TestMux21 IS
7.
8. --
Component Declaration for the Unit U
nder Test (UUT)
9.
10. COMPONENT Mux21
11. PORT(
12. A : IN std_logic;
13. B : IN std_logic;
14. S : IN std_logic;
15. Z : OUT std_logic
16. );
17. END COMPONENT;
18.
19.
20. --Inputs
21. signal A : std_logic := '0';
22. signal B : std_logic := '0';
23. signal S : std_logic := '0';
24.
25. --Outputs
26. signal Z : std_logic;
27.
28. BEGIN
29.
30. --
Instantiate the Unit Under Test (UUT
)
31. uut: Mux21 PORT MAP (
32. A => A,
33. B => B,
34. S => S,
35. Z => Z
36. );
39. begin
40. --
hold reset state for 100 ns.
41. wait for 10 ns;
42. -- insert stimulus here
43.
44. wait;
45. end process;
46.
47. END;
AMBATO-ECUADOR
Ilustración 201 Resultados señales
Ejercicio en clase 1
• TEMA
Convertidor de códigos
• OBJETIVOS
- Objetivo General
➢ Desarrollar un convertidor de código utilizando programación en
VHDL
➢ Desarrollar mediante la tabla de verdad un convertidor de código
➢ Desarrollar un convertidor de código mediante las ecuaciones
➢ Simular cada convertidor utilizando un test bench
- Computadora - ISE design suite
• DESARROLLO
CODIGO RESULTADO
CONVERTIDOR
DE CODIGO
SELECT CODIGO RES
OR
Tabla 3 Convertidor de código [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
AMBATO-ECUADOR
CODIGO GREY EXCESO 3 AIKEN 24121

C3 C2 C1 C0 G3 G2 G1 G0 EX3 EX2 EX1 EX0 E3 E2 E1 E0
0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0
1 0 0 0 1 0 0 0 1 0 1 0 0 0 0 0 1
Ilustración 202 Sistema de
convertidor de 2 0 0 1 0 0 0 1 1 0 1 0 1 0 0 1 0 código
[Guerrero, M; 3 0 0 1 1 0 0 1 0 0 1 1 0 0 0 1 1 Gutiérrez, L;
Manotoa, K; Pérez, C]
4 0 1 0 0 0 1 1 0 0 1 1 1 0 1 0 0
5 0 1 0 1 0 1 1 1 1 0 0 0 1 0 1 1
6 0 1 1 0 0 1 0 1 1 0 0 1 1 1 0 0
7 0 1 1 1 0 1 0 0 1 0 1 0 1 1 0 1
8 1 0 0 0 1 1 0 0 1 0 1 1 1 1 1 0
9 1 0 0 1 1 1 0 1 1 1 0 0 1 1 1 1
10 1 0 1 0 X X X X X X X X X X X X
11 1 0 1 1 X X X X X X X X X X X X
12 1 1 0 0 X X X X X X X X X X X X
13 1 1 0 1 X X X X X X X X X X X X
14 1 1 1 0 X X X X X X X X X X X X
15 1 1 1 1 X X X X X X X X X X X X
➢ Mediante Tabla de verdad:

• Programación
Código principal
1. library IEEE;
3. use IEEE.numeric_std.all;
4. entity Codigo is
5. Port ( a: in STD_LOGIC_VECTOR(3 downto 0);
6. s : in STD_LOGIC_VECTOR(1 downto 0);
7. R : inout STD_LOGIC_VECTOR(3 downto 0);
8. R1 : out STD_LOGIC;
11. R4 : out STD_LOGIC);
12. end Codigo;
13. architecture Behavioral of Codigo is
14. signal e:std_logic_vector(5 downto 0);
15. begin
16. e <= s&a;
17. with e select
18. --<>
19. --00==Reset--
20. --01==GREY--
21. --10==EIKEN 2421--
22. --11==EX3--
23.
24. ------reset------
25. R <= "0000" when "000000",
26. "0000" when "000001",
27. "0000" when "000010",
28. "0000" when "000011",
29. "0000" when "000100",
30. "0000" when "000101",
31. "0000" when "000110",
32. "0000" when "000111",
AMBATO-ECUADOR
33. "0000" when "001000",

34. "0000" when "001001",
35. ------GREY------
36. "0000" when "010000",
37. "0001" when "010001",
38. "0011" when "010010",
39. "0010" when "010011",
40. "0110" when "010100",
41. "0111" when "010101",
42. "0101" when "010110",
43. "0100" when "010111",
44. "1100" when "011000",
45. "1101" when "011001",
46. ------EIKEN 2421------
47. "0000" when "100000",
48. "0001" when "100001",
49. "0010" when "100010",
50. "0011" when "100011",
51. "0100" when "100100",
52. "1011" when "100101",
53. "1100" when "100110",
54. "1101" when "100111",
55. "1110" when "101000",
56. "1111" when "101001",
57. ------EX3------
58. "0011" when "110000",
59. "0100" when "110001",
60. "0101" when "110010",
61. "0110" when "110011",
62. "0111" when "110100",
63. "1000" when "110101",
64. "1001" when "110110",
65. "1010" when "110111",
66. "1011" when "111000",
67. "1100" when "111001",
68. "0000" when others;
69. ----- separación del vector resultante por posiciones-------------
70. R1 <= R(3);

71. R2 <= R(2);
72. R3 <= R(1);
73. R4 <= R(0);
74.
75. end Behavioral;
• RTL Schematic
AMBATO-ECUADOR
Ilustración 203 RTL Schematic. [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
Technology Schematic
AMBATO-ECUADOR
Ilustración 205 Technologic Schematic. [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
• Simulación
AMBATO-ECUADOR
Force Constant
Ilustración 207 Código Gray [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
Ilustración 208 Código Exceso 3 [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
Ilustración 209 Código Aiken 2421 [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
➢ Mediante funciones:
Funciones:
GRAY
𝑐3 = (𝑒3 𝑒2′ 𝑒1′)
𝑐2 = (𝑒3 𝑒2′ 𝑒1′ ) + (𝑒3′ 𝑒2)
𝑐1 = (𝑒3′ 𝑒2 𝑒1′ ) + (𝑒3′ 𝑒2′ 𝑒1)
𝑐0 = (𝑒2′ 𝑒1′ 𝑒0) + (𝑒3′ 𝑒1 𝑒0′ ) + (𝑒3′ 𝑒1′ 𝑒0)
AIKEN 2421
𝑐3 = (𝑒3 𝑒2′ 𝑒1′) + (𝑒3′ 𝑒2′ 𝑒0) + (𝑒3′ 𝑒2′ 𝑒1)
𝑐2 = (𝑒3 𝑒2′ 𝑒1′) + (𝑒3′ 𝑒2′ 𝑒0′) + (𝑒3′ 𝑒2 𝑒1)
𝑐1 = (𝑒3′ 𝑒2 𝑒1′ ) + (𝑒3 𝑒2′ 𝑒1′ ) + (𝑒3′ 𝑒2′ 𝑒1)
𝑐0 = (𝑒2′ 𝑒1′ 𝑒0) + (𝑒3′ 𝑒0′ )
AMBATO-ECUADOR
EXCESO 3
𝑐3 = (𝑒3 𝑒2′ 𝑒1′) + (𝑒3′ 𝑒2′ 𝑒0) + (𝑒3′ 𝑒2 𝑒1)
𝑐2 = (𝑒2′ 𝑒1′ 𝑒0′) + (𝑒3′ 𝑒2 𝑒1′ 𝑒0′) + (𝑒3′ 𝑒2′ 𝑒1)
𝑐1 = (𝑒2′ 𝑒1′ 𝑒0) + (𝑒3′ 𝑒1′ 𝑒0′ ) + (𝑒3′ 𝑒1 𝑒0)
𝑐0 = (𝑒2′ 𝑒1′ 𝑒0′) + (𝑒3′ 𝑒0′)
• Programación
Código principal
1. library IEEE;
3. use ieee.numeric_std.all;
4. use ieee.std_logic_unsigned.all;
5. use ieee.std_logic_arith.all;
6.
7. entity funciones is
8. Port ( entrada : in STD_LOGIC_VECTOR (3 downto 0);
9. salida : out STD_LOGIC_VECTOR (3 downto 0);
10. selector : in STD_LOGIC_VECTOR (1 downto 0);
11. s : out STD_LOGIC;
12. s1 : out STD_LOGIC;
13. s2 : out STD_LOGIC;
14. s3 : out STD_LOGIC);
15. end funciones;
16.
17. architecture Behavioral of funciones is
18. signal e0,e1,e2,e3,c0,c1,c2,c3 : std_logic;
19. signal cr : std_logic_vector(3 Downto 0);
20.
21. begin
22.
23. ------Codigo resultante por posiciones
24. cr(0)<=c0;
25. cr(1)<=c1;
26. cr(2)<=c2;
27. cr(3)<=c3;
28. ------Codigo resultante independientes por posiciones
29. s<=c0;
30. s1<=c1;
31. s2<=c2;
32. s3<=c3;
33. salida<=cr;
34.
35. process(selector,entrada)
36. begin
37. e0<=entrada(0);
38. e1<=entrada(1);
39. e2<=entrada(2);
40. e3<=entrada(3);
41. ------N-BCD----------
42. if(selector="00") then
43. c3<='0';
44. c2<='0';
45. c1<='0';
46. c0<='0';
47. end if;
48. ------GRAY----------
50. c3<=(e3 and(not e2) and (not e1));
51. c2<=(e3 and(not e2)and (not e1))or((not e3)and e2);
AMBATO-ECUADOR
52. c1<=((not e3) and (e2) and(not e1))or((not e3)and(not e2)and(e1));

53. c0<=((not e2)and(not e1)and(e0))or((not e3)and(e1)and(not e0))or((not e3)and(not e1)and(e0
));
54. end if;
55. ------AIKEN 2421----------
57. c3<=(e3 and (not e2)and (not e1))or((not e3) and (e2) and (e0) ) or ((not e3)and(e2)and(e1
) );
58. c2<=(e3 and (not e2)and (not e1))or((not e3) and (e2) and (not e0) ) or ((not e3)and(e2)an
d(e1) );
59. c1<=((not e3) and (e2)and (not e1) and(e0))or((e3) and ( not e2) and (not e1) ) or ((not e
3)and(not e2)and(e1) );
60. c0<=((not e2)and(not e1)and e0) or ((not e3)and e0);
61.
62. end if;
63. ------EXCESO 3----------
64. if (selector ="11") then
65. c3<=(e3 and (not e2)and(not e1)) or ((not e3)and(e3)and(e0)) or((not e3)and(e2)and(e1));
66. c2<=((not e2)and(not e1)and e0) or ((not e3)and (e2)and (not e1) and(not e0))or((not e3)an
d(not e2)and(e1));
67. c1<=((not e2)and(not e1)and(not e0))or ((not e3)and(not e1)and(not e0)) or ((not e3)and(e1
)and(e0));
68. c0<=((not e2)and(not e1)and (not e0)) or ((not e3)and(not e0));
69. end if;
70. end process;
71.
72. end Behavioral;
Código Test bench

1.
USE ieee.std_logic_1164.ALL;
2. -- Uncomment the following library declaration if using
3. -- arithmetic functions with Signed or Unsigned values
4. --USE ieee.numeric_std.ALL;
5. ENTITY cc IS
6. END cc;
7. ARCHITECTURE behavior OF cc IS
9.
10. COMPONENT funciones
11. PORT(
12. entrada : IN std_logic_vector(3 downto 0);
13. salida : OUT std_logic_vector(3 downto 0);
14. selector : IN std_logic_vector(1 downto 0);
15. s : OUT std_logic;
16. s1 : OUT std_logic;
17. s2 : OUT std_logic;
18. s3 : OUT std_logic
19. );
20. END COMPONENT;
21. --Inputs
22. signal entrada : std_logic_vector(3 downto 0) := (others => '0');
23. signal selector : std_logic_vector(1 downto 0) := (others => '0');
24. --Outputs
25. signal salida : std_logic_vector(3 downto 0);
26. signal s : std_logic;
27. signal s1 : std_logic;
30. -- No clocks detected in port list. Replace <clock> below with
31. -- appropriate port name
32.
33. BEGIN
AMBATO-ECUADOR

35. uut: funciones PORT MAP (
36. entrada => entrada,
37. salida => salida,
38. selector => selector,
39. s => s,
40. s1 => s1,
41. s2 => s2,
42. s3 => s3
43. );
44. -- Clock process definitions
47. begin
48. -- hold reset state for 100 ns.
49. entrada <= "0000"; Selector <= "00"; wait for 100 ns;
59.
70.
81.
92.
94.
95. wait;
Tabla 4 Programación de convertidor de código [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]

AMBATO-ECUADOR
• RTL Schematic

AMBATO-ECUADOR
• Technology Schematic
Ilustración 212 Technology Schematic. [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
Ilustración 213 Technology Schematic. [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]

AMBATO-ECUADOR
• Simulación
Test bench
Simulación
Ilustración 214 Código N-BCD. [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
Ilustración 215 Código Gray. [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
Ilustración 216 Código Aiken 2421. [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
Ilustración 217 Código Exceso 3. [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]

AMBATO-ECUADOR
Convertidor de código
Tema
Convertidor de código
Objetivos
➢ General
Realizar un convertidor de código de 4 bits BCD a Gray, Aiken 2421 y Exceso 3

➢ Específicos
• Establecer una señal de entrada de 4 bits tipo bus y un selector de 2 bits
• Establecer una señal de salida de 4 bits tipo bus y otras 4 de cada bit de salida
• Ejecutar empleando modelado estructural
Descripción
Diseñar un convertidor de código de BCD a Gray, Aiken 2421 y Exceso 3, realizar el
programa con la programación en VHDL de los “component” y la simulación
➢ Software de implementación y simulación ISE Design Suite
➢ Apuntes de clase
Tabla de conversiones
S1S0= 01 10 11
Codigo GRAY AIKEN 2421 EX 3
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
0 0 0 1 0 0 0 1 0 0 0 1 0 1 0 0
0 0 1 0 0 0 1 1 0 0 1 0 0 1 0 1
0 0 1 1 0 0 1 0 0 0 1 1 0 1 1 0
0 1 0 0 0 1 1 0 0 1 0 0 0 1 1 1
0 1 0 1 0 1 1 1 1 0 1 1 1 0 0 0
0 1 1 0 0 1 0 1 1 1 0 0 1 0 0 1
0 1 1 1 0 1 0 0 1 1 0 1 1 0 1 0
1 0 0 0 1 1 0 0 1 1 1 0 1 0 1 1
1 0 0 1 1 1 0 1 1 1 1 1 1 1 0 0
1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0
1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0
Tabla 1 Tabla de conversiones de código NBCD a Gray, Aiken 2421 y Exceso 3.
Codificación
Conversor Gray
library IEEE; library IEEE;
use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_1164.ALL;
AMBATO-ECUADOR
-- Uncomment the following library entity conversor_gray is

declaration if using port( NBCD: in std_logic_vector(3
-- arithmetic functions with Signed or downto 0);
Unsigned values GRAY: out std_logic_vector(3
--use IEEE.NUMERIC_STD.ALL; downto 0)
);
-- Uncomment the following library end conversor_gray;
declaration if instantiating
-- any Xilinx primitives in this code. architecture Behavioral of
--library UNISIM; conversor_gray is
--use UNISIM.VComponents.all; signal G3, G2, G1, G0, A, B, C, D:
std_logic;
entity conversor_alto_nivel is
port( NBCD: in std_logic_vector(3 begin
downto 0); A <= NBCD(3);
SALIDA: out std_logic_vector(3 B <= NBCD(2);
downto 0); C <= NBCD(1);
SELECTOR: in std_logic_vector(1 D <= NBCD(0);
downto 0); G3 <= A and not(B) and not(C);
C3, C2, C1, C0: out std_logic G2 <= (not(A) and B) or (A and not(B)
); and not(C));
end conversor_alto_nivel; G1 <= (not(A) and B and not(C)) or
(not(A) and not(B) and C);
architecture Behavioral of G0 <= (not(B) and not(C) and D) or
conversor_alto_nivel is (not(A) and C and not(D)) or (not(A)
COMPONENT conversor_gray and not(C) and D);
PORT(
NBCD : IN std_logic_vector(3 downto GRAY <= G3 & G2 & G1 & G0;
0); end Behavioral;
GRAY : OUT std_logic_vector(3
downto 0)
);
END COMPONENT;
COMPONENT conversor_aiken2421
PORT(
NBCD : IN std_logic_vector(3 downto
0);
AIKEN : OUT std_logic_vector(3
downto 0)
);
END COMPONENT;
COMPONENT conversor_exceso3
PORT(
NBCD : IN std_logic_vector(3 downto
0);
EXCESO3 : OUT std_logic_vector(3
downto 0)
);
END COMPONENT;
AMBATO-ECUADOR
signal CGRAY, CAIKEN, CEXCESO3,

CODIGO: std_logic_vector(3 downto
0);
begin
Inst_conversor_gray: conversor_gray
PORT MAP(
NBCD => NBCD,
GRAY => CGRAY
);
Inst_conversor_aiken2421:
conversor_aiken2421 PORT MAP(
NBCD => NBCD ,
AIKEN => CAIKEN
);
Inst_conversor_exceso3:
conversor_exceso3 PORT MAP(
NBCD => NBCD ,
EXCESO3 => CEXCESO3
);
C3 <= CODIGO(3);
C2 <= CODIGO(2);
C1 <= CODIGO(1);
C0 <= CODIGO(0);
SALIDA <= CODIGO;
with SELECTOR select

CODIGO <= "0000" when "00",
CGRAY when "01",
CAIKEN when "10",
CEXCESO3 when others;
end Behavioral;
Aiken 2421 Exceso 3
entity conversor_aiken2421 is entity conversor_exceso3 is

port( NBCD: in std_logic_vector(3 port( NBCD: in std_logic_vector(3
downto 0); downto 0);
AIKEN: out std_logic_vector(3 EXCESO3: out std_logic_vector(3
downto 0) downto 0)
); );
end conversor_aiken2421; end conversor_exceso3;
architecture Behavioral of architecture Behavioral of

conversor_aiken2421 is conversor_exceso3 is
signal G3, G2, G1, G0, A, B, C, D: signal G3, G2, G1, G0, A, B, C, D:
std_logic; std_logic;
AMBATO-ECUADOR
begin begin
A <= NBCD(3); A <= NBCD(3);
B <= NBCD(2); B <= NBCD(2);
C <= NBCD(1); C <= NBCD(1);
D <= NBCD(0); D <= NBCD(0);
G3 <= (A and not(B) and not(C)) or G3 <= (A and not(B) and not(C)) or
(not(A) and B and D) or (not(A) and B (not(A) and B and D) or (not(A) and B
and C); and C);
G2 <= (A and not(B) and not(C)) or G2 <= (not(B) and not(C) and D) or
(not(A) and B and not(D)) or (not(A) (not(A) and B and not(C) and not(D)) or
and B and C); (not(A) and not(B) and C);
G1 <= (not(A) and B and not(C) and D) G1 <= (not(B) and not(C) and not(D))
or (A and not(B) and not(C)) or (not(A) or (not(A) and not(C) and not(D)) or
and not(B) and C); (not(A) and C and D);
G0 <= (not(B) and not(C) and D) or G0 <= (not(B) and not(C) and not(D))
(not(A) and D); or (not(A) and not(D));
AIKEN <= G3 & G2 & G1 & G0; EXCESO3 <= G3 & G2 & G1 & G0;
end Behavioral; end Behavioral;
Simulación
stim_proc: process NBCD <= "0101";
begin SELECTOR <="10";
wait for 100 ns; wait for 100 ns;
NBCD <= "0001"; NBCD <= "0110";
SELECTOR <="00"; SELECTOR <="11";
NBCD <= "0010"; NBCD <= "0111";
NBCD <= "0011"; NBCD <= "1000";
NBCD <= "0100"; wait;
SELECTOR <="10"; end process;
wait for 100 ns;
Simulación
AMBATO-ECUADOR
Ilustración 4 Simulación del convertidor de código
Resultados
• Cada uno de los conversores se desarrolló de acuerdo a las ecuaciones obtenidas de la tabla
de verdad. Estas ecuaciones se encuentran en los sub módulos VHDL nombrados como
“Inst_”
• A la simulación se le asignó un tiempo de 100ns para cada posible combinación del selector
y del código NBCD
• El programa se desarrolló de acuerdo a los requerimientos planteados en los objetivos, el
programa funciona correctamente.
Tema
Contador MOD 16
Objetivos
➢ General
Realizar un contador MOD 16 con Flip Flops

➢ Específicos
• Establecer una señal de entrada de reloj
• Establecer una señal de salida de 4 bits tipo bus del conteo
Descripción
Diseñar un contador del 0 a 15 mediante Flip Flops tipo D, la señal de entrada será solo del
reloj, todo el conteo se debe realizar siguiendo el modelado estructural, por lo cual será
necesario instanciar cuatro flip flops.
AMBATO-ECUADOR
Codificación
Contador MOD 16
library IEEE; COMPONENT F_F3
use IEEE.STD_LOGIC_1164.ALL; PORT(
a : IN std_logic;
-- Uncomment the following library b : IN std_logic;
declaration if using c : IN std_logic;
-- arithmetic functions with Signed or d : IN std_logic;
Unsigned values c3 : OUT std_logic
--use IEEE.NUMERIC_STD.ALL; );
END COMPONENT;
-- Uncomment the following library
declaration if instantiating signal qs, d: std_logic_vector(3 downto
-- any Xilinx primitives in this code. 0):=(others =>'0');
--library UNISIM; begin
--use UNISIM.VComponents.all; Inst_F_F0: F_F0 PORT MAP(
d => qs(0),
entity ALTO_NIVEL is c0 => d(0)
port( clk, clr: in std_logic; );
numero: out std_logic_vector(3 Inst_F_F1: F_F1 PORT MAP(
downto 0) c => qs(1),
); d => qs(0),
end ALTO_NIVEL; c1 => d(1)
);
architecture Behavioral of Inst_F_F2: F_F2 PORT MAP(
ALTO_NIVEL is b => qs(2),
COMPONENT F_F0 c => qs(1),
PORT( d => qs(0),
d : IN std_logic; c2 => d(2)
c0 : OUT std_logic );
); Inst_F_F3: F_F3 PORT MAP(
END COMPONENT; a => qs(3),
b => qs(2),
COMPONENT F_F1 c => qs(1),
PORT( d => qs(0),
c : IN std_logic; c3 => d(3)
d : IN std_logic; );
c1 : OUT std_logic process (clk, clr)
); begin
END COMPONENT; if clr='1' then
qs <= "0000";
COMPONENT F_F2 elsif (clk'event and clk='1') then
PORT( qs <= D;
b : IN std_logic; end if;
c : IN std_logic; end process;
d : IN std_logic; numero <= qs;
c2 : OUT std_logic end Behavioral;
);
END COMPONENT;
AMBATO-ECUADOR
Flip flop 0 Flip flop 1

entity F_F0 is entity F_F1 is

port( d: in std_logic; port( c, d: in std_logic;
c0: out std_logic c1: out std_logic
); );
end F_F0; end F_F1;
architecture Behavioral of F_F0 is architecture Behavioral of F_F1 is
begin begin
c0 <= not(d); c1 <= (c and not(d)) or (not(c) and d);
end Behavioral;
end Behavioral;
Flip flop 2 Flip flop 3
entity F_F2 is entity F_F3 is

port( b, c, d: in std_logic; port( a, b, c, d: in std_logic;
c2: out std_logic c3: out std_logic
); );
end F_F2; end F_F3;
architecture Behavioral of F_F2 is architecture Behavioral of F_F3 is
begin begin
c2 <= (not(b) and c and d) or (b and c3 <= (not(a) and b and c and d) or (a
not(d)) or (b and not(c)); and not(d)) or (a and not(c)) or (a and
end Behavioral; not(b));
end Behavioral;
Simulación
stim_proc: process
begin
-- hold reset state for 100 ns.
wait for 100 ns;
wait for clk_period*10;
--insert stimulus here

clr <= '0';
wait for 500 ns;
wait;
end process;
Simulación
AMBATO-ECUADOR
Ilustración 5 Simulación del contador MOD 16
Resultados
• Cada uno de los flip flop están diseñados por medio de las ecuaciones obtenidas de la tabla
de verdad. Estas ecuaciones se encuentran en los sub módulos VHDL nombrados como
“Inst_”
• A la simulación se le asignó un tiempo de 500ns a la señal d reloj
Tema
Sumado Completo o Full Adder
Objetivos
➢ General
Realizar un sumador completo mediante dos semisumadores

➢ Específicos
• Establecer 3 señal de entrada de 1 bit
• Establecer 2 señales de salida de 1 bit
Descripción
Diseñar un sumador completo (Full Adder) empleando semisumadores (Half Adder), realizar el
programa con la programación en VHDL mediante modelado estructural
Esquema y ecuaciones
AMBATO-ECUADOR
Ilustración 6 Esquema de Full Adder empleando dos Half Adder

Codificación
Sumador Completo
library IEEE; architecture Behavioral of
use IEEE.STD_LOGIC_1164.ALL; SumadorCompleto is
-- Uncomment the following library COMPONENT SemiSumador1
declaration if using Port (A1 : in STD_LOGIC;
-- arithmetic functions with Signed or B1 : in STD_LOGIC;
Unsigned values S1 : out STD_LOGIC;
--use IEEE.NUMERIC_STD.ALL; CO1 : out STD_LOGIC);
-- Uncomment the following library END COMPONENT;
-- any Xilinx primitives in this code. signal Su1, Su2, Su3:STD_LOGIC;
--library UNISIM; begin
--use UNISIM.VComponents.all; Inst_semisuma1:SemiSumador1 PORT
entity SumadorCompleto is MAP(A1=> A, B1=> B, CO1=> Su1,
Port ( A : in STD_LOGIC; S1=> Su2);
B : in STD_LOGIC; Inst_semisuma2:SemiSumador1 PORT
CI : in STD_LOGIC; MAP(A1=> CI, B1=> Su2, CO1=>
S : out STD_LOGIC; Su3, S1=> S);
CO : out STD_LOGIC); CO<= Su1 or Su3;
end SumadorCompleto; end Behavioral;
Semisumador 1 y 2 Simulación
library IEEE; -- Stimulus process
use IEEE.STD_LOGIC_1164.ALL; stim_proc: process
begin
-- Uncomment the following library -- hold reset state for 100 ns.
declaration if using A <='0'; wait for 25 ns;
-- arithmetic functions with Signed or B <='0'; wait for 25 ns;
Unsigned values CI <='0'; wait for 25 ns;
--use IEEE.NUMERIC_STD.ALL;
A <='0'; wait for 25 ns;
-- Uncomment the following library B <='0'; wait for 25 ns;
declaration if instantiating CI <='1'; wait for 25 ns;
-- any Xilinx primitives in this code.
--library UNISIM; A <='1'; wait for 25 ns;
--use UNISIM.VComponents.all; B <='1'; wait for 25 ns;
CI <='0'; wait for 25 ns;
entity SemiSumador1 is
AMBATO-ECUADOR
Port ( A1 : in STD_LOGIC; A <='1'; wait for 25 ns;

B1 : in STD_LOGIC; B <='0'; wait for 25 ns;
S1 : out STD_LOGIC; CI <='1'; wait for 25 ns;
CO1 : out STD_LOGIC);
end SemiSumador1; A <='1'; wait for 25 ns;
B <='1'; wait for 25 ns;
architecture Behavioral of CI <='1'; wait for 25 ns;
SemiSumador1 is
wait;
begin end process;
S1<= A1 xor B1;

CO1<= A1 and B1;
end Behavioral;
Simulación
Ilustración 7 Simulación de Sumador Completo
Resultados
• Cada uno de los semisumadores se desarrolló con las ecuaciones de un Half Adder. Estas
ecuaciones se encuentran en los sub módulos VHDL nombrados como “Inst_”
• A la simulación se le asignó un tiempo de 25ns para cada posible combinación de valor para
las señales de entra A, B y al acarreo.
Tema
Detector de Código 011
Objetivos
➢ General
AMBATO-ECUADOR
Realizar un detector de código 011 usando Mealy Continuo

➢ Específicos
• Determinar las ecuaciones correspondientes al detector de código continuo de Mealy.
• Diseñar componentes para los F-Fs JK y un programa principal.
• Verificar que el detector funciona correctamente
Descripción
Diseñar un detector de código usando la metodología de Mealy continuo, para detectar el código
“011” empleando flip flops J-K.
Esquemas y Ecuaciones
Ilustración 8 Detector 011 Mealy Continuo
Ilustración 9 Ecuaciones detector 011 Mealy Continuo

Codificación
Programa Test Bench
library IEEE; LIBRARY ieee;
use IEEE.STD_LOGIC_1164.ALL; USE ieee.std_logic_1164.ALL;

declaration if using
declaration if using -- arithmetic functions with Signed or
-- arithmetic functions with Signed or Unsigned values
Unsigned values --USE ieee.numeric_std.ALL;
--use IEEE.NUMERIC_STD.ALL;
ENTITY test IS
-- Uncomment the following library END test;
ARCHITECTURE behavior OF test IS
-- any Xilinx primitives in this code.
--library UNISIM; -- Component Declaration for the
AMBATO-ECUADOR
--use UNISIM.VComponents.all; Unit Under Test (UUT)
entity detector is COMPONENT detector

PORT(
Port ( codigo : in STD_LOGIC;
codigo : IN std_logic;
clk : in STD_LOGIC; clk : IN std_logic;
reset : in STD_LOGIC; reset : IN std_logic;
salida1 : out STD_LOGIC); salida1 : OUT std_logic
end detector; );
END COMPONENT;
architecture Behavioral of detector is
--Inputs
COMPONENT ff_jk signal codigo : std_logic := '0';
PORT( signal clk : std_logic := '0';
j : IN std_logic; signal reset : std_logic := '0';
k : IN std_logic;
clk : IN std_logic; --Outputs
reset : IN std_logic; signal salida1 : std_logic;
q : OUT std_logic
-- Clock period definitions
); constant clk_period : time := 10 ns;
end component;
signal j0,k0,j1,k1,q0,q1 : std_logic; BEGIN
begin -- Instantiate the Unit Under Test

(UUT)
j0<= not codigo;
uut: detector PORT MAP (
k0<= codigo; codigo => codigo,
j1<= codigo and q0; clk => clk,
k1<= '1'; reset => reset,
Inst_ff_jk_1: ff_jk PORT salida1 => salida1
MAP(j=>j0,k=>k0, clk =>clk, reset=> );
reset, q=>q0);
-- Clock process definitions
Inst_ff_jk_2: ff_jk PORT
clk_process :process
MAP(j=>j1,k=>k1, clk =>clk, reset=> begin
reset, q=>q1); clk <= '0';
salida1<= codigo and q1; wait for clk_period/2;
clk <= '1';
end Behavioral; wait for clk_period/2;
end process;
-- Stimulus process
stim_proc: process
begin
reset <= '1'; wait for 0.00001 ns; ---
resetea la maquina
AMBATO-ECUADOR
reset <= '0';

codigo<='0'; wait for 10 ns;
codigo<='1'; wait for 10 ns;---
codigo<='1'; wait for 10 ns;---
codigo<='0'; wait for 10 ns;----
wait;
end process;
END;
Esquema RTL
Ilustración 10 Esquema RTL del detector 011 Mealy continuo

Simulación
AMBATO-ECUADOR
Ilustración 11 Simulación detector de código 011 Mealy continuo

Resultados
• Cada una de las ecuaciones para el detector se desarrolló a través de flip flops J-K. Estas
• El diseño de este detector de código se lo realizo usando las ecuaciones determinadas en
boole, de manera que para ello se tuvo que usar dos instanciaciones ya que utiliza dos flip-
flops JK.
• Para realizar la simulación se procedió a crear un Test Bench en donde se definio los valores
que tendrán las entradas del programa principal.
Tema
Objetivos
➢ General
Realizar un detector de código 101 usando Moore segmentado

➢ Específicos
• Verificar que el detector funciona correctamente mediante la visualización de “10” en la
salida.
Descripción
“1010” y presentar una salida de “10” cuando detecte el código correcto y “01” mientras se detecte
otra secuencia diferente.
Codificación
AMBATO-ECUADOR
Programa principal TestBench

-- Uncomment the following library declaration if using
declaration if using -- arithmetic functions with Signed or
-- arithmetic functions with Signed or Unsigned values
Unsigned values --USE ieee.numeric_std.ALL;
--use IEEE.NUMERIC_STD.ALL; ENTITY simul IS
END simul;
declaration if instantiating ARCHITECTURE behavior OF simul
-- any Xilinx primitives in this code. IS
--library UNISIM; -- Component Declaration for the
--use UNISIM.VComponents.all; Unit Under Test (UUT)
COMPONENT detector1
entity detector1 is PORT(
Port ( clk : in STD_LOGIC; clk : IN std_logic;
I0 : in STD_LOGIC; I0 : IN std_logic;
sal : out STD_LOGIC); sal : OUT std_logic
end detector1; );
END COMPONENT;
architecture Behavioral of detector1 is --Inputs
signal clk : std_logic := '0';
signal Q0: STD_LOGIC :='0'; signal I0 : std_logic := '0';
signal J0,K0: std_logic; --Outputs
signal sal : std_logic;
signal Q1: STD_LOGIC :='0';
signal J1,K1: std_logic; -- Clock period definitions
constant clk_period : time := 0.1 us;
signal Q2: STD_LOGIC :='0'; BEGIN
signal J2,K2: std_logic; -- Instantiate the Unit Under Test
(UUT)
uut: detector1 PORT MAP (
COMPONENT FFjk clk => clk,
PORT( I0 => I0,
clk : IN std_logic; sal => sal
J : IN std_logic; );
K : IN std_logic; -- Clock process definitions
Q : INOUT std_logic clk_process :process
); begin
END COMPONENT; clk <= '0';
begin wait for clk_period/2;
AMBATO-ECUADOR
Inst_Fjk0: FFjk PORT MAP( clk <= '1';

clk =>clk , wait for clk_period/2;
J =>J0 , end process;
K =>K0 , -- Stimulus process
Q =>Q0 stim_proc: process
); begin
Inst_Fjk1: FFjk PORT MAP( I0<='1';
clk =>clk , wait for 0.1 us;
J =>J1 , I0<='0';
K =>K1 , wait for 0.1 us;
Q =>Q1 I0<='1';
); wait for 0.1 us;
Inst_Fjk2: FFjk PORT MAP( I0<='0';
clk =>clk , wait for 0.1 us;
J =>J2 , I0<='1';
K =>K2 , wait for 0.1 us;
Q =>Q2 I0<='0';
); wait for 0.1 us;
I0<='1';
J0<=(Q2 and not Q1)or(I0); wait for 0.1 us;
K0<=(not I0)or(Q2); I0<='0';
J1<=(not I0 and Q0) or (Q2 and Q0); wait for 0.1 us;
K1<=(Q0)or (Q2); I0<='1';
J2<=(I0 and not Q1 and Q0) or (not I0 wait for 0.1 us;
and not Q0) or (not I0 and Q1); I0<='1';
K2<=(I0 and Q1); wait for 0.1 us;
I0<='1';
sal <= Q1 and Q0; wait for 0.1 us;
I0<='0';
end Behavioral; wait for 0.1 us;
I0<='1';
wait for 0.1 us;
I0<='0';
wait for 0.1 us;
I0<='1';
wait for 0.1 us;
I0<='1';
wait for 0.1 us;
I0<='0';
wait for 0.1 us;
I0<='1';
wait for 0.1 us;
I0<='1';
AMBATO-ECUADOR
wait for 0.1 us;

I0<='0';
wait for 0.1 us;
I0<='0';
wait for 0.1 us;
I0<='1';
wait for 0.1 us;
I0<='0';
wait for 0.1 us;
I0<='1';
wait for 0.1 us;
wait;
end process;
END;
Esquema RTL
Ilustración 12 Esquema RTL del detector 101 Moore segmentado

Simulación
AMBATO-ECUADOR
Ilustración 13 Simulación del detector 101 Moore segmentado

Resultados
flops JK.
• Para realizar la simulación se procedió a crear un Test Bench en donde se definio los valores
Tema
Objetivos
➢ General
Realizar un detector de código 101 usando Mealy Continuo

➢ Específicos
• Verificar que el detector funciona correctamente.
Descripción
AMBATO-ECUADOR
Ilustración 14 Detector de código 101 Mealy continuo
Ilustración 15 Ecuaciones para el detector 101 Mealy continuo

Codificación
Programa Test Bench
--DETECTOR DE CODIGO DE 3 LIBRARY ieee;
BITS (101) MEALY CONTINUO USE ieee.std_logic_1164.ALL;
library IEEE;
ENTITY sel3_tb IS
use IEEE.STD_LOGIC_1164.ALL;
END sel3_tb;
------------------------------------------------
--------------------- ARCHITECTURE behavior OF sel3_tb
entity sel3 is IS
Port ( a : in STD_LOGIC;
sf : out STD_LOGIC; COMPONENT sel3
reset : in STD_LOGIC; PORT(
a : IN std_logic;
clk : in STD_LOGIC
sf : OUT std_logic;
); reset : IN std_logic;
end sel3; clk : IN std_logic
------------------------------------------------ );
---------------------- END COMPONENT;
architecture Behavioral of sel3 is --Inputs
signal a : std_logic := '0';
signal reset : std_logic := '0';
signal j0,k0,j1,k1,s,q0,q1 :
STD_LOGIC;--cracion de senales
auxiliares --Outputs
signal sf : std_logic;
component ff
port ( clk, rst, J, K: in std_logic; -- Clock period definitions
constant clk_period : time := 10 ns;
Q: out std_logic);
end component; BEGIN
begin
AMBATO-ECUADOR
---------------------------------------- -- Instantiate the Unit Under Test

--ECUACIONES DE BOOLE (UUT)
j0 <= a; uut: sel3 PORT MAP (
a => a,
k0 <= not a;
sf => sf,
j1 <= (not a and q0); reset => reset,
k1 <= (not a and not q0)or (a and q0); clk => clk
s <= (a and q1 and not q0); );
----------------------------------------
ff1 : ff clk_process :process
begin
port map (
clk <= '0';
j => j0, wait for clk_period/2;
k => k0, clk <= '1';
rst => reset, wait for clk_period/2;
clk => clk, end process;
Q => q0
);
-- Stimulus process
stim_proc: process
ff2 : ff begin
port map ( -- hold reset state for 100 ns.
j => j1, wait for 100 ns;
k => k1, wait for clk_period*10;
rst => reset, -----------------
wait for 10 ns;
clk => clk,
reset <= '1';
Q => q1 wait for 10 ns;
); reset <= '0';
-----------------
sf <= s; -- insert stimulus here
------------------------
end Behavioral; --secuencia para comprobar activacion
de la señal de reloj
a<='0'; wait for 10 ns;
a<='1'; wait for 10 ns;--1
a<='1'; wait for 10 ns;--1
a<='1'; wait for 10 ns;--1
AMBATO-ECUADOR

a<='1'; wait for 10 ns;--1
a<='1'; wait for 10 ns;--1
a<='1'; wait for 10 ns;--1
wait;
end process;
END;
Simulación
Ilustración 16 Simulación del detector de código 101 Mealy continuo

Resultados
Boole Deusto, de manera que para ello se tuvo que usar dos instanciaciones ya que utiliza
dos flip-flops JK.
• Para realizar la simulación se procedió a crear un Test Bench en donde se definió los valores
Tema
AMBATO-ECUADOR
Objetivos
➢ General
Realizar un detector de código 1001 usando Moore Segmentado

➢ Específicos
• Determinar las ecuaciones correspondientes al detector de código segmentado de Moore.
Descripción
Diseñar un detector de código usando la metodología de Moore segmentado, para detectar el código
Ilustración 17 Detector de código 1001 Moore segmentado
Ilustración 18 Ecuaciones para el detector 1001 Moore segmentado

Codificación
Programa Test Bench
entity Detector is
Port ( clk : in STD_LOGIC;
reset : in STD_LOGIC; -- arithmetic functions with Signed or
x : in STD_LOGIC; Unsigned values
scorrecta : out STD_LOGIC; --USE ieee.numeric_std.ALL;
serronea : out STD_LOGIC);
AMBATO-ECUADOR
end Detector; ENTITY testDetector IS

architecture Behavioral of Detector is END testDetector;
signal j0 : std_logic;
ARCHITECTURE behavior OF
signal k0 : std_logic;
testDetector IS
signal j1 : std_logic;
signal k1 : std_logic; -- Component Declaration for the
signal j2 : std_logic; Unit Under Test (UUT)
signal k2 : std_logic;
signal j3 : std_logic; COMPONENT Detector
signal k3 : std_logic; PORT(
clk : IN std_logic;
signal q0 : std_logic;
reset : IN std_logic;
signal q1 : std_logic; x : IN std_logic;
signal q2 : std_logic; scorrecta : OUT std_logic;
signal q3 : std_logic; serronea : OUT std_logic
component ff_jk );
port (j : in STD_LOGIC; END COMPONENT;
k : in STD_LOGIC;
clk : in STD_LOGIC;
--Inputs
reset : in STD_LOGIC; signal clk : std_logic := '0';
q : out STD_LOGIC); signal reset : std_logic := '0';
end component; signal x : std_logic := '0';
begin
j0 <= '1'; --Outputs
signal scorrecta : std_logic;
k0 <= '1';
signal serronea : std_logic;
j1 <= q0;
k1 <= q0; -- Clock period definitions
j2 <= (not x and not q1 and not q0) or (x constant clk_period : time := 10 ns;
and q0) or (x and q1);
k2 <= (q1 and q0) or (x and not q1 and BEGIN
not q0);
-- Instantiate the Unit Under Test
j3 <= (not x and q1 and q0) or (q2 and
(UUT)
q1 and q0); uut: Detector PORT MAP (
k3 <= '1'; clk => clk,
scorrecta <= (q2 and not q1 and not q0); reset => reset,
serronea <= q3; x => x,
ff_0 : ff_jk scorrecta => scorrecta,
port map (j => j0, serronea => serronea
);
k => k0,
clk => clk, -- Clock process definitions
reset => reset, clk_process :process
q => q0 ); begin
ff_1 : ff_jk clk <= '0';
port map (j => j1, wait for clk_period/2;
AMBATO-ECUADOR
k => k1, clk <= '1';

clk => clk, wait for clk_period/2;
reset => reset, end process;
q => q1 );
ff_2 : ff_jk -- Stimulus process
port map (j => j2, stim_proc: process
k => k2, begin
clk => clk, -- hold reset state for 100 ns.
reset => reset, reset <= '1';
q => q2 ); wait for 0.00001 ns;
reset <= '0';
ff_3 : ff_jk
x <= '1';
port map (j => j3, wait for 10 ns;
k => k3, x <= '0';
clk => clk, wait for 10 ns;
reset => reset, x <= '0';
q => q3 ); wait for 10 ns;
end Behavioral; x <= '1';
wait for 10 ns;
x <= '0';
wait for 10 ns;
x <= '1';
wait for 10 ns;
x <= '0';
wait for 10 ns;
x <= '1';
wait for 10 ns;
x <= '1';
wait for 10 ns;
x <= '0';
wait for 10 ns;
x <= '1';
wait for 10 ns;
x <= '0';
wait for 10 ns;
x <= '1';
wait for 10 ns;
x <= '0';
wait for 10 ns;
x <= '0';
wait for 10 ns;
x <= '1';
wait for 10 ns;
x <= '1';
wait for 10 ns;
x <= '0';
wait for 10 ns;
x <= '1';
AMBATO-ECUADOR
wait for 10 ns;

x <= '0';
wait for 10 ns;
x <= '1';
wait for 10 ns;
x <= '0';
wait for 10 ns;
x <= '0';
wait for 10 ns;
x <= '1';
wait for 10 ns;
wait;
end process;
END;
Esquema RTL
Ilustración 19 Esquema RTL del detector 1001 Moore segmentado

Simulación
AMBATO-ECUADOR
Ilustración 20 Simulación del detector de código 1001 de Moore segmentado

Resultados
dos flip-flops JK.
Tema
Objetivos
➢ General
Realizar un detector de código 111 usando Moore Segmentado

➢ Específicos
• Determinar las ecuaciones correspondientes al detector de código segmentado de Moore.
• Diseñar componentes para los F-Fs tipo D y un programa principal.
Descripción
Diseñar un detector de código usando la metodología de Moore segmentado, para detectar el código
“111” empleando flip flops tipo D.
AMBATO-ECUADOR
Ilustración 21 Detector de código 111 Moore segmentado

Componente Ecuación
D0 (X*~Q0)+(X*Q1)
D1 (X*Q0)+(X*Q1)
Z0(salida) (Q1*Q0)
Ilustración 22 Ecuaciones para el detector 111 Moore Segmentado
Codificación
Programa Test Bench
use IEEE.STD_LOGIC_1164.ALL; use USE ieee.std_logic_1164.ALL;
IEEE.STD_LOGIC_ARITH.ALL;
use
IEEE.STD_LOGIC_UNSIGNED.ALL; -- arithmetic functions with Signed or
Unsigned values
entity continuo_111_Moore is Port ( x : --USE ieee.numeric_std.ALL;
in STD_LOGIC;
clk : in STD_LOGIC; reset : in ENTITY cont_111_TB IS END
STD_LOGIC; y1 : out STD_LOGIC); cont_111_TB;
end continuo_111_Moore;
architecture Behavioral of cont_111_TB IS
continuo_111_Moore is COMPONENT -- Component Declaration for the Unit
ff_d Under Test (UUT) COMPONENT
Port ( d : in STD_LOGIC; continuo_111_Moore
clk : in STD_LOGIC; reset : in PORT(
STD_LOGIC; q : out STD_LOGIC); x : IN std_logic; clk : IN std_logic;
reset : IN std_logic; y1 : OUT std_logic
END COMPONENT;
);
END COMPONENT;
signal qA,qB: STD_LOGIC; signal dA,
dB: STD_LOGIC;
--Inputs
begin signal x : std_logic := '0'; signal clk :
std_logic := '0'; signal reset : std_logic
:= '0';
dA <= (x and qB) or (x and qA);
dB <= (x and (not qB)) or (x and qA); --Outputs signal y1 : std_logic;
AMBATO-ECUADOR
Inst_ff_d_0: ff_d PORT MAP(FF_DA -- Clock period definitions

d => dA, clk => clk, constant clk_period : time := 10 ns;
reset => reset, q => qA BEGIN
);
(UUT) uut: continuo_111_Moore
PORT MAP (
Inst_ff_d_1: ff_d PORT MAP(FF_DB x => x,
d => dB, clk => clk, clk => clk, reset => reset, y1 => y1
reset => reset, q => qB );
);
-- Clock process definitions clk_process
:process
y1 <= qB and qA;
begin
clk <= '0';
wait for clk_period/2; clk <= '1';
end Behavioral; wait for clk_period/2;
end process;
-- Stimulus process stim_proc: process
begin
--wait for 100 ns;
--wait for clk_period*10;
-- insert stimulus here

reset <= '1'; wait for 0.00001 ns; reset
<= '0'; --wait for 25 ns;
--wait for 12.5 ns;
x <= '0'; wait for clk_period; --001 x <=

'0'; wait for clk_period;
x <= '1'; wait for clk_period;

x <= '1'; wait for clk_period;--101 x <=



'0'; wait for clk_period; x <= '1'; wait
for clk_period;
AMBATO-ECUADOR



wait;
end process;
END;
Esquema RTL
Ilustración 23 Esquema RTL del detector 111 Moore Segmentado

Simulación
Ilustración 24 Simulacion detector de código 111 Moore segmentado
Resultados
AMBATO-ECUADOR
• Cada una de las ecuaciones para el detector se desarrolló a través de flip flops tipo D. Estas
dos flip-flops tipo D.
Tema
Objetivos
➢ General
Realizar un detector de código 1001 usando Moore Continuo

➢ Específicos
• Determinar las ecuaciones correspondientes al detector de código continuo de Moore.
Descripción
Diseñar un detector de código usando la metodología de Moore continuo, para detectar el código
Codificación
Programa Test Bench
entity DetectorCont is ENTITY Prueba IS
END Prueba;
Port ( Entrada : in STD_LOGIC;
clk : in STD_LOGIC; ARCHITECTURE behavior OF Prueba
reset : in STD_LOGIC; IS
salida,salida1 : out
STD_LOGIC); -- Component Declaration for the
end DetectorCont; Unit Under Test (UUT)
architecture Behavioral of DetectorCont
COMPONENT DetectorCont
is
PORT(
component ff_jk port ( Entrada : IN std_logic;
j: in std_logic; clk : IN std_logic;
k: in std_logic; reset : IN std_logic;
clk: in std_logic; salida,salida1 : OUT std_logic
);
AMBATO-ECUADOR
reset: in std_logic; END COMPONENT;

q: out std_logic
); --Inputs
signal Entrada : std_logic := '0';
end component;
signal s0,j0,k0,j1,k1,j2,k2,q0,q1,q2 : signal reset : std_logic := '0';
std_logic;
begin --Outputs
salida<=s0; signal salida,salida1 : std_logic;
j0<=(q1 or entrada);
k0<=(q1 or (not entrada)); -- Clock period definitions
constant clk_period : time := 10 ns;
j1<=((not entrada) and q0);
k1<=(q0 or entrada); BEGIN
j2<=(entrada and q1 and q0);
k2<='1'; -- Instantiate the Unit Under Test
FF1: ff_jk PORT MAP(j=>j0,k=>k0,clk (UUT)
=>clk, reset=> reset,q=>q0); uut: DetectorCont PORT MAP (
FF2: ff_jk PORT MAP(j=>j1,k=>k1,clk Entrada => Entrada,
clk => clk,
=>clk, reset=> reset,q=>q1);
reset => reset,
FF3: ff_jk PORT MAP(j=>j2,k=>k2,clk salida => salida,
=>clk, reset=> reset,q=>q2); salida1=>salida1
s0<=q2; );
salida1<=not q2;
end Behavioral; -- Clock process definitions
begin
clk <= '0';
wait for clk_period/2;
clk <= '1';
end process;
-- Stimulus process
stim_proc: process
begin
reset <= '1';
wait for 0.00001 ns;
reset <= '0';
entrada<='1'; wait for 10 ns;
AMBATO-ECUADOR

wait;
end process;
END;
Esquema RTL
Ilustración 25 Esquema RTL del detector1001 Moore continuo

Simulación
AMBATO-ECUADOR
Ilustración 26 Simulación del detector de código 1001 Moore continuo

Resultados
dos flip-flops JK.
Tema
Objetivos
➢ General
Realizar un detector de código 101 usando Mealy segmentado

➢ Específicos
• Determinar las ecuaciones correspondientes al detector de código segmentado.
Descripción
Diseñar un detector de código usando la metodología de Mealy segmentado, para detectar el código
Codificación
Programa Principal Test Bench
AMBATO-ECUADOR

use IEEE.STD_LOGIC_ARITH.ALL;
entity Segmentado is -- Uncomment the following library
port (x, clock, reset1 : in std_logic;
-- arithmetic functions with Signed or
y1, y2: out std_logic ); Unsigned values
end Segmentado; --USE ieee.numeric_std.ALL;
architecture Behavioral of Segmentado
is ENTITY Simu_Segmentado IS
END Simu_Segmentado;
component Cod_101 is
port (x, clk, reset : in std_logic;
Simu_Segmentado IS
y1: out std_logic );
end component; -- Component Declaration for the
component Cod_100 is Unit Under Test (UUT)
port (x, clk, reset : in std_logic;
y2: out std_logic ); COMPONENT Segmentado
end component; PORT(
x : IN std_logic;
signal aux1, aux2 :std_logic;
clock : IN std_logic;
begin reset1 : IN std_logic;
InstCod_101 : Cod_101 port map(x=> y1 : OUT std_logic;
x, reset=>reset1 , clk=> clock, y1=> y2 : OUT std_logic
aux1); );
InstCod_100 : Cod_100 port map(x=> END COMPONENT;
x, reset=>reset1 , clk=> clock, y2=>
aux2); --Inputs
b: process (x, aux1, aux2, clock, reset1) signal x : std_logic := '0';
begin signal clock : std_logic := '0';
case aux2 is signal reset1 : std_logic := '0';
when '0' => y1 <= aux1;
when '1' => y1 <= '0'; --Outputs
signal y1 : std_logic;
when others => null;
signal y2 : std_logic;
end case;
end process; -- Clock period definitions
y2 <= aux2; constant clock_period : time := 10 ns;
end Behavioral;
BEGIN

(UUT)
uut: Segmentado PORT MAP (
x => x,
clock => clock,
reset1 => reset1,
y1 => y1,
AMBATO-ECUADOR
y2 => y2
);

clock_process :process
begin
clock <= '0';
wait for clock_period/2;
clock <= '1';
wait for clock_period/2;
end process;
-- Stimulus process
stim_proc: process
begin
wait for 100 ns;
wait for clock_period*10;

-- codigo de prueba "x" : "0010 1010
1110 1011 0110 0101"
x<= '0'; reset1 <= '1'; wait for 10 ns;
x<= '1'; wait for 10 ns; x <= '0'; wait for
10 ns; x<= '1'; wait for 10 ns; x<= '0';
wait for 10 ns;
10 ns; x<= '1'; wait for 10 ns; x<= '0';
wait for 10 ns;
10 ns; x<= '1'; wait for 10 ns; x<= '1';
wait for 10 ns;
10 ns; x<= '1'; wait for 10 ns; x<= '0';
wait for 10 ns;
10 ns; x<= '0'; wait for 10 ns; x<= '0';
wait for 10 ns;
10 ns; x<= '1'; wait for 10 ns; x<= '1';
wait for 10 ns;
AMBATO-ECUADOR
10 ns; x<= '1';

10 ns; x<= '0';
10 ns; x<= '1';
wait;
end process;
END;
Código 101 Código 100
use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_ARITH.ALL;
entity Cod_101 is entity Cod_100 is

port (x, clk, reset : in std_logic; port (x, clk, reset : in std_logic;
y1: out std_logic ); y2: out std_logic );
end Cod_101; end Cod_100;
architecture Behavioral of Cod_101 is architecture Behavioral of Cod_100 is

component FFJK is
Port ( J : in STD_LOGIC;
component FFJK is K : in STD_LOGIC;
Port ( J : in STD_LOGIC; CLOCK : in STD_LOGIC;
K : in STD_LOGIC; RESET : in STD_LOGIC;
CLOCK : in STD_LOGIC; Q : out STD_LOGIC);
RESET : in STD_LOGIC; end component;
Q : out STD_LOGIC); signal aux2 :std_logic;
signal j0, k0, j1, k1, j2, k2:
end component;
STD_LOGIC;
signal aux1 :std_logic; signal q0, q1, q2: STD_LOGIC;
signal j0, k0, j1, k1, j2, k2:
STD_LOGIC; begin
signal q0, q1, q2: STD_LOGIC;
j0 <= (not(x) and q1) or(q2) or(x and
not(q1));
begin
k0 <= (not q1);
j0<=(q2 and not q1) or (x); j1 <= (not(q2) and q0);
k0<=( not x and q2); k1 <= (x and not(q0));
j1<=((not x) and q0) or (q0 and q2); j2 <= (not (x) and q1 and q0);
k1<=(q0 or q2); k2 <= q0 ;
j2<=(x and not q1 and q0) or (not x and aux2<=(q1 and q0);
not q0) or (not x and q1);
c1: FFJK port map (J=> j0, K=> k0,
k2<=(x and q1);
CLOCK =>clk, RESET=>reset,
Q=>q0);
aux1<=(q1 and q0); c2: FFJK port map (J=> j1, K=> k1,
AMBATO-ECUADOR

c1: FFJK port map (J=> j0, K=> k0, Q=>q1);
CLOCK =>clk, RESET=>reset, c3: FFJK port map (J=> j2, K=> k2,
Q=>q0);
Q=>q2);
c2: FFJK port map (J=> j1, K=> k1,
CLOCK =>clk, RESET=>reset, y2<=aux2;
Q=>q1);
c3: FFJK port map (J=> j2, K=> k2, end Behavioral;
Q=>q2);
y1<=aux1;
end Behavioral;
Esquemas RTL
Ilustración 27 Esquema RTL del programa principal

AMBATO-ECUADOR
Ilustración 28 Esquema RTL del código 101
Ilustración 29 Esquema RTL del código 100

Simulación
AMBATO-ECUADOR
Ilustración 30 Simulación del detector de código 101 Mealy segmentado

Resultados
dos flip-flops JK.
Ejercicios Talleres
Ejercicio 1
1. Tema
Sistema de cálculo de complemento A1 y A2 de códigos de 4 bits

2. Objetivos
• Objetivo General
➢ Diseñar un programa en VHDL que permita observar el comportamiento del sistema de
cálculo de complemento A1 y A2 de códigos de 4 bits.
• Objetivos específicos
➢ Utilizar cualquier tipo de programación (tabla, ecuaciones o libre)
➢ Generar los modelos RTL y TECH del problema
➢ Realizar las respectivas simulaciones.
3. Descripción
Se cuenta con un sistema de CÁLCULO de complemento A1 y complemento A2 de códigos de

4 bits y detección de paridad del dato resultante. Se desea analizar la base del funcionamiento
del mencionado sistema empleando los fundamentos de diseño y modelado digital.
AMBATO-ECUADOR
Emplear ISE Design Suite de XILINX para crear la estructura VHDL “COMPLEMENTOS”
que permita modelar el comportamiento del sistema de cálculo de complemento de códigos con
detección de paridad de acuerdo con las especificaciones siguientes:
a. Entrada: Vector de 4 posiciones para código BCD de 4 bits.
b. Selector: Entrada digital para: “0” C-A1 – “1” C-A2.
c. Salidas Independientes: 4 Salidas digitales (C3- C2- C1- C0) para el dato resultante.
d. Salida Agrupada: Vector de 4 posiciones para el dato resultante.
e. Salida de Paridad: Salida digital para: “0” Par – “1” Impar.
f. Modelo RTL Schematic de la Estructura COMPLEMENTOS.
g. Modelo Technology Schematic de la Estructura COMPLEMENTOS.
h. Simulación del sistema de CÁLCULO de complemento A1 y complemento A2 de
códigos de 4 bits y detección de paridad del dato resultante en base a un archivo de asignación
de datos para todos los datos solicitados.
4. Listado De Materiales Y Equipos
• Ise Design Suite
• Apuntes de clase
5. Desarrollo del ejercicio
6. Programación
1. library IEEE;
3. use IEEE.STD_LOGIC_UNSIGNED.ALL;
4. USE IEEE.NUMERIC_STD.ALL;
5.
6. entity COMPLEMENTOS is
7. Port (entrada: in STD_LOGIC_VECTOR (3 DOWNTO 0);
8. selector : in STD_LOGIC;
9. C0 : out STD_LOGIC;
13. salida : out STD_LOGIC_VECTOR (3 downto 0);
14. paridad : out STD_LOGIC);
15. end COMPLEMENTOS;
16.
17. architecture Behavioral of COMPLEMENTOS is
18.
19. signal q0, q1 : std_logic_vector(3 downto 0);
20. begin
21.
22. q0<="0001";
23.
24. process(entrada,selector)
25. begin
26. -------Logica complemento A1 -- negado de la entrada
27. if selector= '0' then
28. q1 <= not entrada;
29. ------Logica complemento A2 -- negado de la entrada + 0001----
30. else
31. q1 <= not entrada + q0;
32. end if;
33. end process;
AMBATO-ECUADOR
34.
35. salida<=q1;
36. --------Logica pariedad ------
37. paridad <= q1(0) xor q1(1) xor q1(2)xor q1(3);
38.
39. C0<=q1(0); C1<=q1(1); C2<=q1(2); C3<=q1(3);
40.
41. end Behavioral;
Modelado RTL
AMBATO-ECUADOR
Modelado Technology Esquematic

AMBATO-ECUADOR
Simulación
Test Bench
1. LIBRARY ieee;
3.
4. ENTITY Simulacion_compl IS
5. END Simulacion_compl;
6.
7. ARCHITECTURE behavior OF Simulacion_compl IS
8.
10.
11. COMPONENT COMPLEMENTOS
12. PORT(
13. entrada : IN std_logic_vector(3 downto 0);
14. selector : IN std_logic;
15. C0 : OUT std_logic;
19. salida : OUT std_logic_vector(3 downto 0);
20. paridad : OUT std_logic
21. );
22. END COMPONENT;
23.
24.
25. --Inputs
AMBATO-ECUADOR
26. signal entrada : std_logic_vector(3 downto 0) := (others => '0');

27. signal selector : std_logic := '0';
28.
29. --Outputs
30. signal C0 : std_logic;
34. signal salida : std_logic_vector(3 downto 0);
35. signal paridad : std_logic;
36. BEGIN
37.
39. uut: COMPLEMENTOS PORT MAP (
40. entrada => entrada,
41. selector => selector,
42. C0 => C0,
43. C1 => C1,
44. C2 => C2,
45. C3 => C3,
46. salida => salida,
47. paridad => paridad
48. );
49.
50.
51. entrada<="0000" after 50 ns,"0001" after 100 ns,"0010" after 150 ns,"0011"
after 200 ns,"0100" after 250 ns,"0101" after 300 ns,"0110" after 350
ns,"0111" after 400 ns,"1000" after 450 ns,"1001" after 500 ns, "1010" after
550 ns,"1011" after 600 ns,"1100" after 650 ns, "1101" after 700 ns,"1110"
after 750 ns,"1111" after 800 ns,
52. "0000" after 850 ns,"0001" after 900 ns,"0010" after 950 ns,"0011" after
1000 ns,"0100" after 1050 ns,"0101" after 1100 ns,"0110" after 1150
ns,"0111" after 1200 ns,"1000" after 1250 ns,"1001" after 1300 ns, "1010"
after 1350 ns,"1011" after 1400 ns,"1100" after 1450 ns, "1101" after 1500
ns,"1110" after 1550 ns,"1111" after 1600 ns;
53. selector<= '0' after 0 ns, '1' after 850 ns;
54.
55.
END;
Visor de Ondas
AMBATO-ECUADOR
7. Resultados
Mediante programación en VHDL se realizó un programa que permite el calculo del complemento
A1 y A2 de un numero binario de 4 bits, el calculo respectivo es controlado por un selector que
según su posición realizará la transformación a complemento A1 o A2.
Ejercicio 2
1. Tema
Generador de Código
2. Objetivos
3. Objetivo General
➢ Diseñar un programa en VHDL que permita observar el comportamiento de un generador de
Código de 4 bits.
4. Objetivos Específicos
➢ Realizar las respectivas programaciones de un generador de códigos
➢ Utilizar el modelo estructural para poder realizar el programa.
➢ Generar la simulación para observar los resultados.
5. Descripción
Se cuenta con un sistema de Generación de códigos de 4 bits. Se desea analizar la base del
funcionamiento del mencionado sistema empleando los fundamentos de diseño y modelado
digital. Emplear ISE Design Suite de XILINX para crear la estructura VHDL “GENERADOR”
que permita modelar el comportamiento del sistema de generación de códigos de acuerdo con
las especificaciones siguientes:
a. Selector: Entrada digital para: “0” Código 1 (0101) – “1” Código 1 (0011).
b. Salida Independiente (Serial para el código resultante.
c. Modelo RTL Schematic de la Estructura.
d. Modelo Technology Schematic de la Estructura.
AMBATO-ECUADOR
e. Simulación del sistema de generación de códigos de 4 bits en base a un archivo de

asignación de datos para todos los datos solicitados.
Programación
Generador de código 0011
1. library IEEE;
2. use IEEE.std_logic_1164.all;
3. use work.STATE_CONST.all;
4.
5. entity generador is
6. port(wave : out std_logic;
7. clk : in std_logic
8. );
9. end entity generador;
10.
11. architecture fsm of generador is
12. signal state : std_logic_vector(STATE_BITS-1 downto 0);
13. signal temp_wave : std_logic;
14. begin
15. --Calculo del proximo estado
16. proximo_estado: process (clk)
17. begin
18. if (rising_edge(clk)) then
19. case state is
20. when S0 => state <= S1; wave <= '0';
24. when others => state <= S1; wave <= '0';
25. end case;
26. end if;
27. end process proximo_estado;
28. end architecture fsm;
Generador de código 0101

1. library IEEE;
2. use IEEE.std_logic_1164.all;
3. use work.STATE_CONST.all;
4.
5. entity generador2 is
8. );
9. end entity generador2;
10.
11. architecture fsm of generador2 is
AMBATO-ECUADOR

14. begin
17. begin
19. case state is
25. end case;
26. end if;
Principal
1. library IEEE;
3.
4.
5. entity gen3 is
6. Port ( sel : in STD_LOGIC;
7. wave : out STD_LOGIC;
8. clk : in STD_LOGIC
9. );
10. end gen3;
11.
12. architecture Behavioral of gen3 is
13.
14. signal s1,s2,salida: std_logic;
15.
16. component generador
17. port (wave : out std_logic;
19.
20. );
21. end component;
22.
23. component generador2
24. port (wave : out std_logic;
26.
27. );
28. end component;
29.
30. begin
31.
32. cod1 : generador
33.
34. port map (
35. wave => s1,
AMBATO-ECUADOR
36. clk => clk

37.
38. );
39. cod2 : generador2
40.
41. port map (
42. wave => s2,
43. clk => clk
44.
45. );
46. wave<=salida;
47. process (s1,s2,sel,salida)
48. begin
49. if sel = '0' then
50. salida <= s2;
51. else
52. salida <= s1;
53. end if;
54. end process;
55. end Behavioral;
Modelado RTL
AMBATO-ECUADOR
Simulación
AMBATO-ECUADOR
Test bench
1. LIBRARY ieee;
3.
4. -- Uncomment the following library declaration if using
5. -- arithmetic functions with Signed or Unsigned values
6. --USE ieee.numeric_std.ALL;
7.
8. ENTITY simulagen3 IS
9. END simulagen3;
10.
11. ARCHITECTURE behavior OF simulagen3 IS
12.
14.
15. COMPONENT gen3
16. PORT(
17. sel : IN std_logic;
18. wave : OUT std_logic;
19. clk : IN std_logic
20. );
21. END COMPONENT;
22.
23.
24. --Inputs
25. signal sel : std_logic := '0';
26. signal clk : std_logic := '0';
27.
28. --Outputs
29. signal wave : std_logic;
30.
31. -- Clock period definitions
32. constant clk_period : time := 10 ns;
33.
34. BEGIN
35.
37. uut: gen3 PORT MAP (
38. sel => sel,
39. wave => wave,
40. clk => clk
41. );
42.
44. clk_process :process
45. begin
46. clk <= '0';
47. wait for clk_period/2;
48. clk <= '1';
50. end process;
51.
52.
AMBATO-ECUADOR

55. begin
57. wait for 100 ns;
58.
59. wait for clk_period*10;
60.
62.
63. wait;
64. end process;
65.
66. END;
Visor de Ondas
8. Resultados
Mediante programación en VHDL se realizó un programa que permite generar dos códigos bit a
bit “0101” y ”0011”, controlados por una entrada selector que dependiendo su posición dará a
su salida un código distinto.
AMBATO-ECUADOR
TEMA
Programación y simulación de un circuito combinacional usando lenguaje VHDL
OBJETIVOS
Objetivo General
✓ Realizar la programación y simulación de un circuito combinacional.
✓ Desarrollar los programas mediante su tabla de verdad circuito y ecuación de salida
✓ Conocer el funcionamiento de cada entorno de ISE Design Suite
✓ Realizar las simulaciones
✓ Computadoras
DESARROLLO
Se requiere simular la tabla de verdad ecuación de salida y circuito del siguiente diagrama
combinacional:
Ilustración 218 Circuito propuesto.
Mediante su ecuación de salida:
1. library IEEE; 16. end Behavioral;

2. use IEEE.STD_LOGIC_1164.ALL; 17. Mediante su tabla de verdad
3. entity EjProp1 is 18.
4. Port ( A : in STD_LOGIC; 19. library IEEE;
5. B : in STD_LOGIC; 20. use IEEE.STD_LOGIC_1164.ALL;
6. C : in STD_LOGIC; 21. use IEEE.STD_LOGIC_ARITH.ALL;
7. Z : out STD_LOGIC); 22. use IEEE.STD_LOGIC_UNSIGNED.ALL;
8. end EjProp1; 23.
9. 24. entity TablaProp is
10. architecture Behavioral of EjProp1 is 25. Port ( A : in STD_LOGIC_VECTOR(2
downto 0);
11. 26. Z : out STD_LOGIC);
12. begin 27. end TablaProp;
13. z<= (not A and B) or (not A) or(A and 28.
C); 29. architecture Behavioral of TablaProp
14. is
15. 30.
AMBATO-ECUADOR
31. begin 35. '1' when others;

32. with A select 36.
33. z<= '0' when "100", 37. end Behavioral;
34. '0' when "110",
Mediante su circuito
Ilustración 219 Circuito a realizar
1. library IEEE;
3.
4.
5. entity Prop1Circuito is
8. C : in STD_LOGIC;
10. end Prop1Circuito;
11.
12. architecture Behavioral of Prop1Circuito is
13. signal Oo,O1 : STD_LOGIC;
14. begin
15. Oo<= (not A and B);
16. O1<= (not A and C);
17. z<= (not A) or Oo or O1;
18. end Behavioral;
RESULTADOS
Resultados ecuación de salida:
1. LIBRARY ieee; 13. B : IN std_logic;
2. USE ieee.std_logic_1164.ALL; 14. C : IN std_logic;
3. ENTITY TestProp1 IS 15. Z : OUT std_logic
4. END TestProp1; 16. );
5. 17. END COMPONENT;
6. ARCHITECTURE behavior OF TestProp1 IS 18. --Inputs
19. signal A : std_logic := '0';
7. 20. signal B : std_logic := '0';
8. -- 21. signal C : std_logic := '0';
Component Declaration for the Unit U 22.
nder Test (UUT) 23. --Outputs
9. 24. signal Z : std_logic;
10. COMPONENT EjProp1 25. --
11. PORT( No clocks detected in port list. Rep
12. A : IN std_logic; lace <clock> below with
AMBATO-ECUADOR
26. -- appropriate port name 38.

27. 39. -- Stimulus process
28. BEGIN 40. stim_proc: process
29. 41. begin
30. -- 42. --
Instantiate the Unit Under Test (UUT hold reset state for 100 ns.
) 43. wait for 100 ns;
31. uut: EjProp1 PORT MAP ( 44. -- insert stimulus here
32. A => A, 45.
33. B => B, 46. wait;
34. C => C, 47. end process;
35. Z => Z 48.
36. ); 49. END;
Ilustración 220 Simulación ecuación de salida
Resultados tabla de verdad
Ilustración 221 Tabla ej propuesto 1
1. LIBRARY ieee; 8. --
2. USE ieee.std_logic_1164.ALL; Component Declaration for the Unit U
3. ENTITY TestTabla IS nder Test (UUT)
4. END TestTabla; 9.
5. 10. COMPONENT TablaProp
6. ARCHITECTURE behavior OF TestTabla IS 11. PORT(
12. A : IN std_logic_vector(2 d
7. ownto 0);
AMBATO-ECUADOR
13. Z : OUT std_logic 30. --

14. ); Instantiate the Unit Under Test (UUT
15. END COMPONENT; )
16. 31. uut: TablaProp PORT MAP (
17. 32. A => A,
18. --Inputs 33. Z => Z
19. signal A : std_logic_vector(2 down 34. );
to 0) := (others => '0'); 35.
20. 36. -- Clock process definitions
21. --Outputs 37.
22. signal Z : std_logic; 38. -- Stimulus process
23. -- 39. stim_proc: process
No clocks detected in port list. Rep 40. begin
lace <clock> below with 41. --
24. -- appropriate port name hold reset state for 100 ns.
25. 42. wait for 10 ns;
26. 43. -- insert stimulus here
27. 44.
28. BEGIN 45. wait;
47.
48. END;
Ilustración 222 Resultado tabla de verdad
Resultados Circuito:
1. LIBRARY ieee; 13. A : IN std_logic;

2. USE ieee.std_logic_1164.ALL; 14. B : IN std_logic;
3. 15. C : IN std_logic;
4. ENTITY TestEjCircuito IS 16. Z : OUT std_logic
5. END TestEjCircuito; 17. );
6. 18. END COMPONENT;
7. ARCHITECTURE behavior OF TestEjCircui 19.
to IS 20.
8. 21. --Inputs
9. -- 22. signal A : std_logic := '0';
Component Declaration for the Unit U 23. signal B : std_logic := '0';
nder Test (UUT) 24. signal C : std_logic := '0';
10. 25.
11. COMPONENT Prop1Circuito 26. --Outputs
12. PORT( 27. signal Z : std_logic;
AMBATO-ECUADOR
28. BEGIN 39.

30. -- 41. stim_proc: process
Instantiate the Unit Under Test (UUT 42. begin
) 43. --
31. uut: Prop1Circuito PORT MAP ( hold reset state for 100 ns.
32. A => A, 44. wait for 100 ns;
33. B => B, 45. -- insert stimulus here
34. C => C, 46. wait;
35. Z => Z 47. end process;
36. ); 48.
37. 49. END;
Ilustración 223 Resultados Circuito
TEMA
Demostrar la programación de un circuito básico secuencial en VHDL
OBJETIVOS
Objetivo General
✓ Realizar la programación de un circuito básico secuencial en VHDL
✓ Realizar la simulación del circuito mediante función de salida y señales internas
✓ Demostrar el funcionamiento del circuito
✓ Computadora
DESARROLLO
Desarrollo mediante señales internas
1. library IEEE;
3. entity Prop2 is
AMBATO-ECUADOR
7. end Prop2;
8.
9. architecture Behavioral of Prop2 is
10.
11. begin
12. z<=(A or B)and B;
13.
14. end Behavioral;
Desarrollo mediante señales
1. library IEEE;
3.
4. entity Prop2 is
8. end Prop2;
9.
10. architecture Behavioral of Prop2 is
11. signal C0:STD_LOGIC;
12. begin
13. C0<=A or B;
14. z<= C0 and B;
15.
16. end Behavioral;
RESULTADOS
Resultado mediante ecuacion de salida:
Ilustración 224 Resultado Ecuación
1. LIBRARY ieee; 7. ARCHITECTURE behavior OF Testeo IS

2. USE ieee.std_logic_1164.ALL; 8.
3. 9. --
4. ENTITY Testeo IS Component Declaration for the Unit U
5. END Testeo; nder Test (UUT)
6. 10.
AMBATO-ECUADOR
11. COMPONENT Prop2 30. uut: Prop2 PORT MAP (

12. PORT( 31. A => A,
13. A : IN std_logic; 32. B => B,
14. B : IN std_logic; 33. Z => Z
15. Z : OUT std_logic 34. );
16. ); 35.
17. END COMPONENT; 36.
19. 38. stim_proc: process
20. --Inputs 39. begin
21. signal A : std_logic := '0'; 40. --
22. signal B : std_logic := '0'; hold reset state for 100 ns.
23. 41. wait for 100 ns;
24. --Outputs 42. -- insert stimulus here
25. signal Z : std_logic; 43.
26. 44. wait;
27. BEGIN 45. end process;
28. 46.
29. -- 47. END;
Instantiate the Unit Under Test (UUT
)
48.
Resultado mediante señales
Ilustración 225 Resultado señales
1. LIBRARY ieee; 19.

2. USE ieee.std_logic_1164.ALL; 20.
3. 21. --Inputs
4. 22. signal A : std_logic := '0';
5. ENTITY Testeo IS 23. signal B : std_logic := '0';
6. END Testeo; 24.
7. 25. --Outputs
8. ARCHITECTURE behavior OF Testeo IS 26. signal Z : std_logic;
9. 27. --
10. -- No clocks detected in port list. Rep
Component Declaration for the Unit U lace <clock> below with
nder Test (UUT) 28. -- appropriate port name
11. 29.
12. COMPONENT Prop2 30.
13. PORT( 31.
14. A : IN std_logic; 32. BEGIN
15. B : IN std_logic; 33.
16. Z : OUT std_logic 34. --
17. ); Instantiate the Unit Under Test (UUT
18. END COMPONENT; )
AMBATO-ECUADOR
35. uut: Prop2 PORT MAP ( 45. --

36. A => A, hold reset state for 100 ns.
37. B => B, 46. wait for 100 ns;
38. Z => Z 47. -- insert stimulus here
39. ); 48.
40. 49. wait;
42. -- Stimulus process 51.
43. stim_proc: process 52. END;
44. begin
53.
• TEMA
Código exceso 3 verificar si es número par e impar.
• OBJETIVOS
- Objetivo General
o Realizar la programación y simulación del ingreso de código exceso 3 y verificar si es
número par e impar.
o Desarrollar el programa mediante tabla de verdad
o Conocer el funcionamiento de cada entorno de ISE Design Suite
o Realizar las simulaciones
➢ Computadoras
➢ ISE Design Suite
• DESARROLLO
CODIGO
C3 C2 C1 C0 PAR IMPAR
0 0 0 0 1 0
0 0 0 1 0 1
0 0 1 0 1 0
0 0 1 1 0 1
0 1 0 0 1 0
0 1 0 1 0 1
0 1 1 0 1 0
0 1 1 1 0 1
1 0 0 0 1 0
1 0 0 1 0 1
AMBATO-ECUADOR
Tabla 5 Tabla de verdad Código. [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
• Programación
Código Principal
1. library IEEE;
3. use IEEE.numeric_std.all;
4. entity convertir is
5. Port ( Entrada : in STD_LOGIC_VECTOR (3 downto 0);
6. Selector : in STD_LOGIC ;
7. Salida : out STD_LOGIC_VECTOR (3 downto 0));
8.
9. end convertir;
10. architecture Behavioral of convertir is
11. signal sv: std_logic_vector(3 downto 0):="0000";
12.
13. begin
14.
15. Salida<=sv;
16. process (Selector, Entrada)
17. begin
18.
19. ----------- par---------------
20. if Selector = '0' then
21. if Entrada ="0000" then
22. sv <="0001";
23. end if;
25. sv <="0000";
26. end if;
28. sv <="0001";
29. end if;
31. sv <="0000";
32. end if;
34. sv <="0001";
35. end if;
37. sv <="0000";
38. end if;
40. sv <="0001";
41. end if;
43. sv <="0000";
44. end if;
46. sv <="0001";
47. end if;
49. sv <="0000";
50. end if;
51. end if;
52. ----------- impar---------------
53. if Selector = '1' then
55. sv <="0000";
56. end if;
58. sv <="0001";
AMBATO-ECUADOR
59. end if;

61. sv <="0000";
62. end if;
64. sv <="0001";
65. end if;
67. sv <="0000";
68. end if;
70. sv <="0001";
71. end if;
73. sv <="0000";
74. end if;
76. sv <="0001";
77. end if;
79. sv <="0000";
80. end if;
82. sv <="0001";
83. end if;
84. end if;
85. end process;
86. end Behavioral;
Código test bench

1. LIBRARY ieee;
3.
4. ENTITY PAR IS
5. END PAR;
6.
7. ARCHITECTURE behavior OF PAR IS
8.
10.
11. COMPONENT convertir
12. PORT(
13. Entrada : IN std_logic_vector(3 downto 0);
14. Selector : IN std_logic;
15. Salida : OUT std_logic_vector(3 downto 0)
16. );
17. END COMPONENT;
18. --Inputs
19. signal Entrada : std_logic_vector(3 downto 0) := (others => '0');
20. signal Selector : std_logic := '0';
21.
22. --Outputs
23. signal Salida : std_logic_vector(3 downto 0);
26.
27. BEGIN
28.
30. uut: convertir PORT MAP (
31. Entrada => Entrada,
32. Selector => Selector,
33. Salida => Salida
AMBATO-ECUADOR
34. );
35.
37.
40. begin
42. --PAR
43. Entrada<="0000"; Selector <= '0'; wait for 100 ns;
53. --IMPAR
54.
65.
67.
68. wait;
69. end process;
70.
71. END;
Tabla 6 Ejercicio propuesto. [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
• RTL Schematic

AMBATO-ECUADOR
• Technologic Schematic

AMBATO-ECUADOR
• Simulación
Test bench
Ilustración 230 Simulación número par. [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
Ilustración 231Simulación numero impar. [Guerrero, M; Gutiérrez, L; Manotoa, K; Pérez, C]
Tema: Contador MOD12 en base a un MOD16

AMBATO-ECUADOR
Objetivos
➢ General
Diseñar un contador MOD12 mediante el uso de un MOD16

➢ Específicos
Crear un contador MOD16 usando instanciación de F-Fs JK.

Crear un contador MOD12 usando el componente del contador MOD16.
Descripción
Diseño de un contador MOD12 usando instanciación por componentes en donde se hace uso de un
contador MOD16, este contador usa F-Fs JK, con una transición adecuada de reloj y con opción de
reset.
Ilustración 31 Esquema del contador MOD 16
CODIGO
PROGRAMA PRINCIPAL SIMULACION
library IEEE;
use IEEE.STD_LOGIC_1164.ALL; LIBRARY ieee;
use IEEE.STD_LOGIC_ARITH.ALL; USE ieee.std_logic_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
ENTITY SIMU_MOD_10 IS
entity MOD10 is END SIMU_MOD_10;
port(ck : in std_logic;
salida : out std_logic_vector(3 downto 0)
); ARCHITECTURE behavior OF SIMU_MOD_10 IS
end MOD10;
COMPONENT MOD10
architecture Behavioral of MOD10 is PORT(
signal s3, s2, s1, s0 : std_logic; ck : IN std_logic;
signal sale_aux : std_logic_vector(3 downto 0); salida : OUT std_logic_vector(3 downto 0)
signal reset : std_logic:='1'; );
COMPONENT MOD16 END COMPONENT;
PORT(
ck : IN std_logic; --Inputs
reset : IN std_logic; signal ck : std_logic := '0';
qs : OUT std_logic_vector(3 downto 0)
); --Outputs
END COMPONENT; signal salida : std_logic_vector(3 downto 0);
AMBATO-ECUADOR
begin
MOD10: MOD16 PORT MAP(ck =>ck ,reset =>reset ,qs constant ck_period : time := 10 ns;
=>sale_aux );
s3 <= sale_aux(3);
s2 <= sale_aux(2); BEGIN
s1 <= sale_aux(1);
s0 <= sale_aux(0); -- Instantiate the Unit Under Test (UUT)
reset <= s3 and s2; uut: MOD10 PORT MAP (
salida <=sale_aux; ck => ck,
salida => salida
end Behavioral; );

ck_process :process
begin
ck <= '0';
wait for ck_period/2;
ck <= '1';
wait for ck_period/2;
end process;
-- Stimulus process
stim_proc: process
begin
wait for 100 ns;
--wait for <clock>_period*10;
wait;
end process;
END;
Ilustración 32 Simulación del contador MOD12
Resultados
AMBATO-ECUADOR
• Para el diseño del contador MOD 12 se realiza un contador MOD16 que va a formar parte
del programa principal, así mismo los flip-flops que conforman el contador MOD12 están
definidos como componentes en la sintaxis del MOD16.
• Para la simulación se crea un Test Bench en donde no se realiza ninguna asignación de
valores excepto en el del reloj, que en ocasiones se asigna automáticamente y otras debemos
cambiar <clock> por el nombre que se haya asignado para la señal de reloj.
• En la simulación el conteo lo realiza de manera adecuada, tal como se lo había descrito al
inicio es un conteo desde el 0 hasta 11, la misma función que se repite varias veces.
Tema
Registro de desplazamiento de 4 bits
Objetivos
➢ General
Realizar un registro de desplazamiento de 4 bits usando FFs-D.

➢ Específicos
• Determinar las ecuaciones correspondientes al registro de desplazamiento.
• Diseñar componentes para los FFs tipo D y un programa principal.
• Verificar que el registro funciona correctamente mediante la simulación.
Descripción
Diseño de un registro de desplazamiento de 4 bits usando Flip Flops tipo de los cuales se conectan
en cascada y son síncronos. El registro desplazará los bits que lleguen de forma serial y serán
presentados de forma paralela.
Ilustración 33 Esquema del registro de 4 bits con salida paralela.
CODIGO
AMBATO-ECUADOR
LIBRARY ieee;
library IEEE; USE ieee.std_logic_1164.ALL;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL; ENTITY SIMU_REGISTRO IS
use IEEE.STD_LOGIC_UNSIGNED.ALL; END SIMU_REGISTRO;
ARCHITECTURE behavior OF SIMU_REGISTRO IS

entity registro is
port(serial_in, ck : in std_logic; -- Component Declaration for the Unit Under Test
(UUT)
q3, q2, q1, q0 : out std_logic
); COMPONENT registro
end registro; PORT(
serial_in : IN std_logic;
architecture Behavioral of registro is ck : IN std_logic;
q3 : OUT std_logic;
COMPONENT FF_D q2 : OUT std_logic;
PORT(d : IN std_logic; q1 : OUT std_logic;
clk : IN std_logic; q0 : OUT std_logic
q : OUT std_logic );
); END COMPONENT;
END COMPONENT;
signal q3_aux, q2_aux, q1_aux, q0_aux : std_logic;
begin --Inputs
signal serial_in : std_logic := '0';
FF3: FF_D PORT MAP(d =>serial_in ,clk => ck,q => signal ck : std_logic := '0';
q3_aux);
FF2: FF_D PORT MAP(d => q3_aux,clk => ck,q => --Outputs
q2_aux); signal q3 : std_logic;
FF1: FF_D PORT MAP(d => q2_aux,clk => ck,q => signal q2 : std_logic;
q1_aux); signal q1 : std_logic;
signal q0 : std_logic;
FF0: FF_D PORT MAP(d => q1_aux,clk => ck,q => -- No clocks detected in port list. Replace <clock>
q0_aux); below with
q3 <= q3_aux; -- appropriate port name
q2 <= q2_aux;
q1 <= q1_aux; constant ck_period : time := 10 ns;
q0 <= q0_aux;
end Behavioral; BEGIN
-- Instantiate the Unit Under Test (UUT)

---------------------COMPONENTE FFD-------------------- uut: registro PORT MAP (
library IEEE; serial_in => serial_in,
use IEEE.STD_LOGIC_1164.ALL; ck => ck,
use IEEE.STD_LOGIC_ARITH.ALL; q3 => q3,
use IEEE.STD_LOGIC_UNSIGNED.ALL; q2 => q2,
q1 => q1,
q0 => q0
entity FF_D is );
port(d, clk : in std_logic;
q : out std_logic); -- Clock process definitions
end FF_D; ck_process :process
begin
ck <= '0';
architecture Behavioral of FF_D is wait for ck_period/2;
signal q_aux : std_logic; ck <= '1';
begin wait for ck_period/2;
end process;
process(clk)
begin
if (clk'event and clk='1') then q_aux<=d;
-- Stimulus process
end if; stim_proc: process
AMBATO-ECUADOR
end process; begin

q <= q_aux; wait for 100 ns;
serial_in <= '1';
end Behavioral; wait for 100 ns;
serial_in <= '0';
wait for 100 ns;
wait;
end process;
END;
Ilustración 34 Simulación del registro de desplazamiento con salida paralela.
Resultados
• El diseño del registro de desplazamiento se lo realizo basándose en el diagrama propuesto,
donde todos lo FF-D están conectado en forma de cascada y están configurados de manera
asíncrona.
• Para realizar la simulación se procedió a crear un Test Bench en donde definimos los valores
• Los datos ingresan de manera serial y según detecta los flancos ascendentes sigue
desplazándose hacia la derecha y se toman los bits de salida de cada FF-D de forma paralela.
Tema
Objetivos
➢ General
Realizar un detector de código 1010 usando Mealy

➢ Específicos
AMBATO-ECUADOR
• Verificar que el detector funciona correctamente mediante la visualización de “10” en la

salida.
Descripción
“1010” y presentar una salida de “10” cuando detecte el código correcto y “01” mientras se detecte
otra secuencia diferente.
CODIGO
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
library IEEE;
use IEEE.STD_LOGIC_1164.ALL; ENTITY SIMU_ALTO_NIVEL IS
use IEEE.STD_LOGIC_ARITH.ALL; END SIMU_ALTO_NIVEL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
ARCHITECTURE behavior OF SIMU_ALTO_NIVEL IS
entity detector is
port(entra, clk, reset : in std_logic; -- Component Declaration for the Unit Under Test
sale : out std_logic_vector(1 downto 0) (UUT)
);
end detector;
COMPONENT detector
PORT(
architecture Behavioral of detector is entra : IN std_logic;
COMPONENT FFJK clk : IN std_logic;
PORT( reset : IN std_logic;
j : IN std_logic; sale : OUT std_logic_vector(1 downto 0)
k : IN std_logic; );
clk : IN std_logic; END COMPONENT;
reset : IN std_logic;
sale : OUT std_logic
);
END COMPONENT; --Inputs
signal j0, k0, j1, k1, q0, q1,s0, s1 : std_logic:='0'; signal entra : std_logic := '0';
begin signal clk : std_logic := '0';
--logica de entrada signal reset : std_logic := '0';
j0 <= entra;
k0 <= not entra; --Outputs
j1 <= (not entra and q0); signal sale : std_logic_vector(1 downto 0);
k1 <= (not entra and not q0) or (not entra and q0);
--logica de salida
s0 <= (not q0) or (not q1) or (entra); -- Clock period definitions
s1 <= (not entra and q1 and q0); constant clk_period : time := 10 ns;
--flip flops
FF0: FFJK PORT MAP(j =>j0 ,k =>k0 ,clk =>clk ,reset =>reset BEGIN
,sale =>q0 );
FF1: FFJK PORT MAP(j =>j1 ,k =>k1 ,clk =>clk ,reset =>reset -- Instantiate the Unit Under Test (UUT)
,sale =>q1 ); uut: detector PORT MAP (
sale <= s1&s0; entra => entra,
end Behavioral; clk => clk,
reset => reset,
sale => sale
AMBATO-ECUADOR
);

begin
clk <= '0';
clk <= '1';
end process;
-- Stimulus process
stim_proc: process
begin
-- wait for 100 ns;
--wait for clk_period*10;

entra<= '0'; reset <= '1'; wait for 10 ns;
entra<= '1'; wait for 10 ns; entra <= '0'; wait for 10 ns;
entra<= '1'; wait for 10 ns; entra<= '0'; wait for 10 ns;
entra<= '1';
entra<= '0';
entra<= '1';
wait;
end process;
END;
AMBATO-ECUADOR
Ilustración 35 Simulación del detector de Mealy continuo.
Resultados
flops JK.
• Para realizar la simulación se procedió a crear un Test Bench en donde definimos los valores
• Se ingresó un código al azar, por lo que en la simulación se identifica el código ingresado y
además detecta el código 1010 cuando la salida es 10.
Ejercicios Taller
EJERCICIO 1
1. Tema
Sumador binario de 4 bits

2. Objetivos
3. Objetivo General
• Implementar un sistema sumador de 4 bits

4. Objetivos específicos
• Analizar el funcionamiento de un semisumador.
• Instanciar un semisumador en la estructura de un sumador de 4 bits.
• Verificar el correcto funcionamiento de nuestro sistema sumador de 4 bits.
5. Descripción
AMBATO-ECUADOR
Se realizará un sumador completo de 4 bits tomando como referencia un semisumador básico e

instanciándolo en nuestro programa principal
Programación
Semi - sumador
1. library IEEE;
3.
4. entity semi is
5. port (a : in std_logic;
6. b : in std_logic;
7. carry : out std_logic;
8. suma : out std_logic);
9. end semi;
10.
11. architecture Behavioral of semi is
12.
13. begin
14. suma <= a xor b;
15. carry <= a and b;
16.
17. end Behavioral;
Sumador de 4 bits
1. library IEEE;
3.
4. entity sumador_4bits is
5. port (a : in std_logic_vector(3 downto 0);
6. b : in std_logic_vector(3 downto 0);
7. r : out std_logic_vector(4 downto 0));
8. end sumador_4bits;
9.
10. architecture Behavioral of sumador_4bits is
11.
12. COMPONENT semi
13. port (a : in std_logic;
14. b : in std_logic;
15. carry : out std_logic;
16. suma : out std_logic);
17. end component;
18. signal a1, a2, a3, a4 : std_logic;
19. signal b1, b2, b3, b4 : std_logic;
20. signal c1, c2, c3, c4, cout1, cout2, cout3, cout4 : std_logic;
21. signal s1, s2, s3, s4: std_logic;
22. signal f1, f2, f3, f4 : std_logic;
AMBATO-ECUADOR
23. signal r1, r2, r3, r4, r5 : std_logic;

24.
25. begin
26. a1 <= a(0);
27. a2 <= a(1);
28. a3 <= a(2);
29. a4 <= a(3);
30.
31. b1 <= b(0);
32. b2 <= b(1);
33. b3 <= b(2);
34. b4 <= b(3);
35.
36. ss1 : semi
37. port map (
38. a => a1,
39. b => b1,
40. carry => c1,
41. suma => s1
42. );
43. ss2 : semi
44. port map (
45. a => a2,
46. b => b2,
47. carry => c2,
48. suma => s2
49. );
50. ss3 : semi
51. port map (
52. a => a3,
53. b => b3,
54. carry => c3,
55. suma => s3
56. );
57. ss4 : semi
58. port map (
59. a => a4,
60. b => b4,
61. carry => c4,
62. suma => s4
63. );
64. r1 <= s1;
65. r2 <= s2 xor c1;
66. f2 <= s2 and c1;
67. cout2 <= c2 or f2;
68.
69. r3 <= s3 xor cout2;
70. f3 <= s3 and cout2;
71. cout3 <= c3 or f3;
72.
73. r4 <= s4 xor cout3;
74. f4 <= s4 and cout3;
75. r5 <= c4 or f4;
76.
77.
AMBATO-ECUADOR
78. r(0) <= r1;

79. r(1) <= r2;
80. r(2) <= r3;
81. r(3) <= r4;
82. r(4) <= r5;
83.
84.
85. end Behavioral;
Modelado RTL
AMBATO-ECUADOR
Simulación
Test bench
1. LIBRARY ieee;
3.
4.
5. ENTITY simu_sumador IS
6. END simu_sumador;
7.
8. ARCHITECTURE behavior OF simu_sumador IS
9.
10. COMPONENT sumador_4bits
11. PORT(
12. a : IN std_logic_vector(3 downto 0);
13. b : IN std_logic_vector(3 downto 0);
14. r : OUT std_logic_vector(4 downto 0)
15. );
16. END COMPONENT;
17.
18.
AMBATO-ECUADOR
19. --Inputs
20. signal a : std_logic_vector(3 downto 0) := (others => '0');
21. signal b : std_logic_vector(3 downto 0) := (others => '0');
22.
23. --Outputs
24. signal r : std_logic_vector(4 downto 0);
27.
28.
29. BEGIN
30.
32. uut: sumador_4bits PORT MAP (
33. a => a,
34. b => b,
35. r => r
36. );
37.
39. process
40. begin
42.
43.
45. a <= "0101";
46. b <= "1100";
47.
49. a <= "0100";
50. b <= "1001";
52.
53. wait;
54. end process;
55.
56. END;
Visualizador de resultados
AMBATO-ECUADOR
8. Resultados
Como podemos observar en la programación instanciaos el programa del semisumador y lo

utilizamos en el sumador de 4 bits conectándolo como una cascada para el correcto
funcionamiento del mismo y como se presentó en la simulación el sumador está funcionando los
resultados de manera óptima y correcta.
EJERCICIO 2
1. Tema
Generador de Código “1110”

2. Objetivos
3. Objetivo General
➢ Diseñar un programa en VHDL que permita observar el comportamiento de un generador de
Código de 4 bits.
4. Objetivos específicos
➢ Realizar las respectivas programaciones de un generador de códigos
➢ Utilizar el modelo estructural para poder realizar el programa.
➢ Generar la simulación para observar los resultados.
5. Descripción
Realizar un programa en VHDL que permita generar un codigo de salida bit a bit 1110 el cual
cambiara con cada ciclo de reloj
Programación
1. entity generador is
4. );
5. end entity generador;
6.
7. architecture fsm of generador is
10. begin
13. begin
15. case state is
AMBATO-ECUADOR

21. end case;
22. end if;
Modelado RTL

AMBATO-ECUADOR
Simulación
Test Bench
1. LIBRARY ieee;
3. ENTITY sim IS
4. END sim;
5.
6. ARCHITECTURE behavior OF sim IS
7.
8.
9. COMPONENT generador
10. PORT(
11. wave : OUT std_logic;
12. clk : IN std_logic
13. );
14. END COMPONENT;
15.
16.
17. --Inputs
18. signal clk : std_logic := '0';
19.
20. --Outputs
21. signal wave : std_logic;
22.
23. -- Clock period definitions
24. constant clk_period : time := 10 ns;
25.
26. BEGIN
27.
29. uut: generador PORT MAP (
30. wave => wave,
31. clk => clk
32. );
33.
AMBATO-ECUADOR

35. clk_process :process
36. begin
37. clk <= '0';
39. clk <= '1';
41. end process;
42.
43.
44. END;
Visor de Ondas
8. Resultados
Mediante programación en VHDL se realizó un programa que permite generar un código bit a bit
“1110” el cual ira cambiando conforme señal de reloj vaya entrando al componente.
1. CUESTIONARIO
Reactivo 1.
Enunciado. – Relacione las palabras con su respectivo significado.
1 Drivers A Lleva el programa al microcontrolador

AMBATO-ECUADOR
2 Compilador B Reconoce la placa, configura el tipo de

dispositivo
3 Interfaz de transferencia C Revisa la sintaxis y genera el archivo (.hex)
Opciones de Respuesta:
a) 1A, 2B, 3C
b) 1B, 2C, 3A
c) 1C, 2A, 3B
d) 1A, 2C, 3B
Respuesta correcta: b
Justificación:
• Drivers: Reconoce la placa, configura el tipo de dispositivo.
• Compilador: Revisa la sintaxis y genera el archivo (*.hex).
• Interfaz de transferencia: Lleva el programa al microcontrolador.
Nivel de dificultad: Medio.
Fuente de verificación:
Programación y Ejecución, Libro Ronald J. Tocci, Capitulo 13, Arquitectura de dispositivos
Logicos Programables, página 868.
Reactivo 2.
Enunciado. – Seleccione la respuesta correcta.
FPGA es considerado un dispositivo de………………. que ejecuta

todo………………., llamándose a este proceso de
ejecución……………….
a alta velocidad; a la vez; secuencial

b alta velocidad; por intervalos, combinacional
c alta velocidad; a la vez; concurrente
d alta velocidad; por intervalos, preliminar
Opciones de Respuesta: De la opción “a” hasta la opción “d”.
Respuesta correcta: c
Justificación:
FPGA es considerado un dispositivo de alta velocidad que ejecuta todo a la vez., llamándose
a este proceso de ejecución concurrente.
Nivel de dificultad: Medio
Programación y Ejecución, Libro Ronald J. Tocci, Capitulo 13, Árbol Familiar de los
Sistemas Digitales página 870.
AMBATO-ECUADOR
Reactivo 3.
Enunciado. – Complete con la respuesta correcta.
Los circuitos combinacionales vienen a ser divididos en ………, aritméticos,

………y lógicos, los mismos que están compuestos únicamente por puertas
lógicas interconectadas entre sí, sin ningún ……. o celda de memoria.
a lógicas – aritméticas – biestables.
b estables – aritméticas – estables.
c lógicas – aritméticas – estables.
d estables – aritméticas – biestables.
Respuesta correcta: a
Justificación:
Los circuitos combinacionales vienen a ser divididos en lógicos, aritméticos, aritméticos y
lógicos, los mismos que están compuestos únicamente por puertas lógicas interconectadas
entre sí, sin ningún biestables o celda de memoria.
Programación y Ejecución, Libro Ronald J. Tocci, Capitulo 4, Circuitos Lógicos
Combinacionales página 118.
Reactivo 4.
Enunciado. – Seleccione la respuesta correcta
Un Sistema Secuencial Asíncrono posee ………………. Además, sus

variables de estados …………………….
a condiciones iniciales; cambian constantemente.

b condiciones de diseño; no cambian simultáneamente.
c condiciones finales; cambian simultáneamente.
d condiciones; se mantienen simultáneamente.
Justificación:
Un Sistema Secuencial Asíncrono posee condiciones de diseño. Además, esta posee sus
variables de estados no cambian simultáneamente.
AMBATO-ECUADOR
Programación y Ejecución, Libro Ronald J. Tocci, Capitulo 7, Contadores Asíncronos,
página 362.
Reactivo 5.
Un sistema digital es el conjunto de dispositivos para el procesado de

……………. que serán convertidas en señales digitales es decir señales con
…………...
a Señales físicas, Valores discretos.
b Señales analógicas, Valores discretos.
c Señales digitales, Valores discretos.
d Señales físicas, Valores continuos.
Justificación:
Un sistema digital es el conjunto de dispositivos para el procesado de señales físicas que
serán convertidas en señales digitales es decir señales con valores discretos
página 370.
Reactivo 6.
Microprocesador es aquel dispositivo cuyo propósito es solventar las

exigencias del usuario mediante su previa …………, este dispositivo está
…………. por su arquitectura a su vez es de carácter abierta la cual le
permite jugar con sus ……………...
a Programación, limitado, componentes

b Programación, limitado, dispositivos
c Programación, limitado, drivers
d Simulación, limitado, componentes

AMBATO-ECUADOR
Justificación:
Microprocesador es aquel dispositivo cuyo propósito es solventar las exigencias del usuario
mediante su previa programación, este dispositivo está limitado por su arquitectura a su vez
es de carácter abierta la cual le permite jugar con sus componentes
página 378.
Reactivo 1.
Enunciado. - Seleccione la respuesta correcta.
¿Cuándo un FSM es del tipo Mealy?
Seleccione la respuesta correcta

A) Cuando su salida depende tanto de la entrada como del estado de la máquina.
B) Cuando su salida no depende de nada.
C) Cuando su salida depende únicamente del estado actual de la máquina.
D) Cuando su salida depende únicamente de la entrada.
Respuesta correcta: A
Justificación: Se dice que un FSM es del tipo Mealy cuando su entrada puede afectar la
salida directamente. En otras palabras, la salida ahora no depende únicamente del estado de
la máquina, sino que también depende del valor de entrada.
Fuente de verificación: T. L. Floyd, Fundamentos de sistemas digitales, Madrid: Pearson ,

2006
Reactivo 2.
2. La cantidad de estados de un FSM de tipo Mealy respecto al de tipo Moore es:

A) Menor
B) Mayor
C) Igual
Respuesta correcta: A
AMBATO-ECUADOR
Justificación: Esto se debe al uso de la dependencia de entrada para reducir el número de

estados necesarios para cumplir las especificaciones para una entrada determinada
Fuente de verificación: M. Alavi, S. Aliaga y M. Murga, «Máquinas de Estado Finito

Finite State Machines,» Revistas Bolivianas, vol. 8, pp. 41-57, 2016
Reactivo 3.
3. ¿Cuándo un FSM es del tipo Moore?
A) Cuando su salida no depende de nada
B) Cuando su salida depende tanto de la entrada como del estado de la máquina.
C) Cuando su salida depende únicamente de la entrada.
D) Cuando su salida depende únicamente del estado actual de la máquina.
Respuesta correcta: D
Justificación: Se dice que un FSM es del tipo Moore cuando su salida depende únicamente
del estado actual de la máquina. En otras palabras, la salida no se ve afectada directamente
por la entrada (la entrada solo puede afectar el siguiente estado de la máquina)..
Fuente de verificación: M. Alavi, S. Aliaga y M. Murga, «Máquinas de Estado Finito

Finite State Machines,» Revistas Bolivianas, vol. 8, pp. 41-57, 2016.
Reactivo 4.
4. La característica más destacable de un diagrama de estados en el modelo de Mealy es:

A) Su salida únicamente se encuentra en el estado
B) Tanto su salida como su entrada se encuentran en la transición
C) Tanto su salida como su entrada se encuentran en el estado
D) Su salida únicamente se encuentra en la transición
Respuesta correcta: B
Justificación: El autómata de Mealy se diferencia del modelo de Moore si en su diagrama

de estados se encuentra la entrada y su salida en la transición entre los estados.

AMBATO-ECUADOR
Fuente de verificación: T. L. Floyd, Fundamentos de sistemas digitales, Madrid: Pearson ,

2006
Reactivo 5.
5. Siendo X: Entrada, Y: Estado y Z: Salida, la función matemática que representa a un

FMS
tipo Moore es:

A) Y=f(Z)
B) Z=f(X,Y)
C) Z=f (Y)
D) Y=f(Z,X)
Respuesta correcta: C
Justificación: La característica de un FMS tipo Moore es que La característica de un FMS

tipo Moore es que su salida depende únicamente del estado en el cual se encuentre la
máquina, por ende, Z=f (Y)
Fuente de verificación: T. L. Floyd, Fundamentos de sistemas |digitales, Madrid: Pearson ,

2006
Reactivo 1
Enunciado. - Seleccione la respuesta correcta
Un detector de secuencia de Mealy realiza un análisis de todos sus ……. para identificar
tanto la secuencia correcta o incorrecta, dentro de esta puede existir dos, la forma
………………. estos dos tipos de soluciones se diferencia por los estados que va a
desarrollos ya que en la segmentada tiene más estados que la continua
a Estados; continua y segmentada
b Transiciones; continua
c Estados; de detección y control
d Transiciones; continua y segmentada
Justificación:
Un detector de secuencia de Mealy realiza un análisis de todos sus estados para identificar tanto
la secuencia correcta o incorrecta, dentro de esta puede existir dos la forma continua y
segmentada estos dos tipos de soluciones se diferencia por los estados que va a desarrollos ya
que en la segmentada tiene más estados que la continua.
Fuente de verificación: Libro Sistemas Digitales Síncronos y VHDL de Wilson Oswaldo
Baldeon.
AMBATO-ECUADOR
Reactivo 2
En un detector de secuencia de Mealy, para poder sincronizar la maquina secuencial junto
con el contador colocado a la salida de esta se debe usar:
a Latch de Salida
b Latch de entrada
c Señal de reloj
d Contador secuencial
Justificación:
Un Latch es un circuito electrónico biestable asíncrono usado para almacenar información en
sistemas lógicos digitales, dentro de las maquinas secuenciales de Mealy nos permite
sincronizar nuestras señales CLK con nuestra transición es evitando así posibles errores o
retardos.

Fuente de verificación: Universidad de Cantabria, Circuitos Lógicos Secuenciales de Pablo
Abad.
Reactivo 3
¿Qué es un Latch y para que se lo usa?
a Es un circuito electrónico usado como contador.
b Es un circuito electrónico monoestable asíncrono usado para almacenar información
en sistemas lógicos digitales.
c Es un circuito electrónico biestable asíncrono usado para almacenar información en
sistemas lógicos digitales.
d Es un circuito electrónico usado como una señal de reloj
Justificación:
Un Latch es un circuito electrónico biestable asíncrono usado para almacenar información en

sistemas lógicos digitales

Fuente de verificación: Universidad de Cantabria, Circuitos Lógicos Secuenciales de Pablo
Abad.
Reactivo 4
Un detector de secuencia de tipo continuo únicamente tiene la configuración de:
a Cadena de código correcto y código erróneo y retroalimentaciones
b Cadena de secuencia
c Retroalimentaciones
d Cadena de secuencia principal y retroalimentaciones
Respuesta correcta: d
Justificación:
AMBATO-ECUADOR
Un detector de secuencia tipo continuo ya sea Mealy o Moore va a usar la configuración de una
cadena de secuencias principal de acuerdo con los estados que se posea y las
retroalimentaciones a cada uno de los estados, formando así una cadena lineal.

Baldeon.
Reactivo 5
Un detector de secuencia de tipo segmentado únicamente tiene la configuración de:
a Cadena de código correcto y código erróneo y retroalimentaciones
b Cadena de secuencia
c Retroalimentaciones
d Cadena de secuencia principal y retroalimentaciones
Justificación:
Un detector de secuencia tipo segmentado ya sea Mealy o Moore va a usar la configuración de
una cadena de código correcto y código erróneo de acuerdo con los estados que se posea y las
retroalimentaciones a cada uno de los estados, manejando así cadenas de estados que nos
permite visualizar en forma clara en donde estamos y que secuencia estamos siguiendo
Baldeon.
Reactivo 1.
Arduino es una ……………. electrónica de código …………. basada en hardware y software
fáciles de usar.
a Plataforma – abierto
b Placa – abierto
c Plataforma – cerrado
d Tarjeta – compatible
Justificación: Arduino es una plataforma electrónica de código abierto basada en hardware y
software fáciles de usar.
Nivel de dificultad: dificultad baja
Fuente de verificación: (2020, Arduino cc, página oficial de Arduino), Apuntes de clase
Reactivo 2.
Enunciado. Completar de acuerdo con la respuesta correcta.
El archivo …....... dentro del Sofware ….......... es conjunto de códigos binarios escrito en
hexadecimal que establece la …........... y el código.
a .bit-Xilinx-herramienta
AMBATO-ECUADOR
b .hex - pic c compiler - dirección

c .hex-arduino-direccion
d .hex-pic c compiler-herramienta
Justificación: El archivo hex dentro del Sofware Pic C Compiler es conjunto de códigos binarios
escrito en hexadecimal que establece la dirección y el código.
Nivel de dificultad: dificultad baja
Fuente de verificación: (2010, Ing. David Apaza Condori, pág. 13)
Reactivo 3.
Enunciado: Seleccione la respuesta correcta.
Es una de las principales plataformas electrónicas de bricolaje ampliamente reconocida en todo el
mundo. Se utiliza tanto para el aprendizaje de la electrónica, la creación de prototipos electrónicos
y sólo para usos de aficionados.
a Pic C Compiler
b Arduino
c MPLAB
d Proteus
Justificación: Arduino es una de las principales plataformas electrónicas de bricolaje ampliamente
reconocida en todo el mundo. Se utiliza tanto para el aprendizaje de la electrónica, la creación de
prototipos electrónicos y sólo para usos de aficionados.
Nivel de dificultad: dificultad media
Fuente de verificación: (2016, Briejo Eduardo, pag.15), Apuntes de clase
Reactivo 4.
Enunciado. Identifique a que tipo de Software corresponden las siguientes características.
Facilidad de programación, al gran número de fuentes de conocimiento disponibles, a la gran
compatibilidad de la placa con diversos dispositivos e interfaces y a la amplia gama de adiciones y
ampliaciones disponibles. Una gran ventaja es también el precio, que es muy atractivo, lo que
constituye una indudable ventaja especialmente para los jóvenes, por ejemplo, los estudiantes de las
universidades o los estudiantes técnicos.
a Arduino
b Proteus
c Pic C Compiler
d Arduino IDE
Justificación: Arduino es uno de los artículos más recomendados para los principiantes de la
electrónica. Esto se debe a varios factores, sobre todo a la facilidad de programación, al gran
número de fuentes de conocimiento disponibles, a la gran compatibilidad de la placa con diversos
dispositivos e interfaces y a la amplia gama de adiciones y ampliaciones disponibles. Una gran
ventaja es también el precio, que es muy atractivo, lo que constituye una indudable ventaja
especialmente para los jóvenes, por ejemplo, los estudiantes de las universidades o los estudiantes
técnicos.
Nivel de dificultad: dificultad media
Fuente de verificación: (2020, Arduino cc, página oficial), Apuntes de clase.
AMBATO-ECUADOR
Reactivo 5.
Enunciado.
Un…………. es un sistema ……. totalmente en una sola pastilla. Tenemos que los
………………no alcanzan el nivel de…………….. de, por ejemplo, un 8086, aunque poseen la
ventaja de trabajar sin memoria…………...
a Arduino-integrado-Arduinos-procesamiento-interno
b Pickit- externo- pines-máxima capacidad-interna
c Microcontrolador- integrado- microcontroladores- procesamiento- externa
d Arduino-integrado-módulos Arduino-procesamiento-externo
Justificación: Un microcontrolador es un sistema integrado totalmente en una sola pastilla.
Tenemos que los microcontroladores no alcanzan el nivel de procesamiento de por ejemplo, un
8086, aunque poseen la ventaja de trabajar sin memoria externa.
Nivel de dificultad: dificultad alta
Fuente de verificación: (2010, Apaza Daviz, pág. 10), Apuntes de clase.

Reactivo 1.
1 ATMega A Es un circuito integrado programable, capaz de ejecutar
las órdenes grabadas en su memoria
2 Bits B Es el microcontrolador más común e utilizado en
Arduino.
3 Microcontroladores C Unidad mínima de información, que puede tener solo dos
valores.
e) 1A, 2B, 3C
f) 1B, 2C, 3A
g) 1C, 2A, 3B
h) 1A, 2C, 3B
Justificación:
• ATMega: Es el microcontrolador más común e utilizado en Arduino.
• Bits: Unidad mínima de información, que puede tener solo dos valores.
• Microcontroladores: Es un circuito integrado programable, capaz de ejecutar las órdenes
grabadas en su memoria
M. Pilatasig, L. Mena y J. Sánchez, Programacion de Modulos de Comunicacion, Latacunga:
Universidad de las Fuerzas Armadas ESPE, 2018.
AMBATO-ECUADOR
Reactivo 2.
Las librerías son archivos ……. que ayudan a los programas para que obtengan más…. Estas
funciones controlan el ………… y agrega funciones de procesamiento al ………….
a compilados; funciones; hardware; software

b fragmentados; programas, interior; exterior
c descargados; frecuencia; hardware; software
d verificados; volumen, hardware; software
Justificación:
Las librerías son archivos compilados que ayudan a los programas para que obtengan más
funciones. Estas funciones controlan el hardware y agrega funciones de procesamiento al
software.
Reactivo 3.
Los fusibles son …… de ………. de funcionamiento, los cuales pueden habilitar o
deshabilitar ………….
a bits – configuración – servicios.

b estados – arreglo – funciones.
c biestables – distribución – acciones.
d estables – ordenación - comandos.
Justificación:
Los fusibles son bits de configuración de funcionamiento, los cuales pueden habilitar o
deshabilitar servicios.
AMBATO-ECUADOR

Reactivo 4.
Arduino es una ……. de desarrollo basada en una placa electrónica de hardware libre que
incorpora un ……… re-programable y una serie de …… hembra.
a plataforma; microcontrolador; pines

b multiplataforma; circuito cerrado; entradas
c Base de datos; regulador de corriente; conexiones
d plataforma; cerebro electrónico; pines
Justificación:
Arduino es una plataforma de desarrollo basada en una placa electrónica de hardware libre que
incorpora un microcontrolador re-programable y una serie de pines hembra.
E. P. Municio, F. Remiro Dominguez y L. López Pérez , Microcontrolador PICI 6F84: Desarollo
de Poyectos, México: Aliaoiiiega Grupo, 2004.
Reactivo 5

1 Librería A Función asociada a un evento o programa.
2 Fusible B Programas compilados que agregan funciones.
3 Interruptores C Bits de configuración que Habilita/Deshabilita servicios
i) 1A, 2B, 3C
j) 1B, 2C, 3A
k) 1C, 2A, 3B
l) 1A, 2C, 3B
Justificación:
• Librería Programas compilados que agregan funciones.
AMBATO-ECUADOR
• Fusibles: Bits de configuración que Habilita/Deshabilita servicios

• Interruptores: Función asociada a un evento o programa.
E. P. Municio, F. Remiro Dominguez y L. López Pérez , Microcontrolador PICI 6F84:
Desarollo de Poyectos, México: Aliaoiiiega Grupo, 2004.
1. TEMA 6 (Control DIO,AIO, Sensores y Actuadores)
6. Control DIO,AIO, Sensores y Actuadores

Reactivo 1.
Enunciado. -Escoja la respuesta correcta
¿Qué es un dispositivo de entrada y salida digital (DIO)?

a. Es un software que envía señales análogas.
b. Es un hardware que recibe señales digitales.
c. Es un hardware que envía o recibe señales análogas.
d. Es un hardware que envía o recibe señales digitales.
Justificación:
Una señal digital es una señal que existe en uno de dos estados: alta o baja, abierta o cerrada,
encendida o apagada. Un dispositivo de entrada y salida digital (DIO) es un hardware que
envía o recibe estas señales digitales. Los dispositivos DIO generalmente se construyen
alrededor de relés simples como los relés de láminas.
Nivel de Dificultad: Medio
Fuente de Verificación:
S. d. r. B. Box., «Black Box,» 2005. Available: https://www.blackbox.com.
Reactivo 2.
Enunciado
Un dispositivo _____ es un ---_______ que envía o recibe señales de entrada y salida

______básicamente es el complemento del control DIO ya que estos trabajan
conjuntamente.
a. DIO, hardware, digital.
b. AIO, hardware, análoga.
c. AIO, software, digital.
d. DIO, hardware, análoga.
AMBATO-ECUADOR
Justificación:
Un dispositivo AIO es un hardware que envía o recibe señales de entrada y salida análoga,
básicamente es el complemento del control DIO ya que estos trabajan conjuntamente.
C. y. robótica, «Sindofdez Wordpress,» 2015. Available: https://sindofdez.wordpress.com.
Reactivo 3.
Enunciado.-Escoja la respuesta correcta
¿Qué permite la modulación por ancho de pulso?

a. Cambiar la luminosidad de un LED o controlar la velocidad de un motor de corriente
continua.
b. Cambiar la luminosidad de un LED o controlar la velocidad de un motor de corriente
alterna.
c. Cambiar la intensidad de un LED o controlar la velocidad de un motor de corriente
alterna.
d. Cambiar la intensidad de un LED o controlar la velocidad de un motor de corriente
continua.
Justificación:
La modulación por ancho de pulso permite, por ejemplo, cambiar la luminosidad de un LED
de manera gradual o controlar la velocidad de un motor de corriente continua.
WordPress, «Salida Analoga,» Available: https://galaxi0.wordpress.com.
Reactivo 4.
Enunciado.
Señale los tipos de actuadores correctos.

a. Electrónicos, Hidráulicos, matemáticos.
b. Eléctricos, motores, geométricos.
c. Eléctrico, electrónico, hidráulico.
d. Motores, Eléctricos, matemáticos.
AMBATO-ECUADOR
Justificación:
Existen varios tipos de actuadores como son:

Electrónicos
Hidráulicos
Neumáticos
Eléctricos
Motores
Bombas
Actuadores, Eugenio Vildósola C. Soltex Chile S.A.-

http://www.aie.cl/files/file/comites/ca/abc/actuadores.pdf
7. Comunicaciones
Reactivo 1.
Que función de Modulo CCP permite, obtener el valor del temporizador en un momento dado,
fijado por la acción de un terminal del PIC.
a Captura
b Comparador
c PWM
a) Captura
b) Comparador
c) PWM
Justificación:
• Comparar: Compara el valor del temporizador con el valor de un registro y provoca
una acción en el PIC.
• Captura: Obtiene el valor del temporizador en un momento dado, fijado por la acción
de un terminal del PIC.
• PWM: Genera una señal modulada por ancho de pulso.
https://controlautomaticoeducacion.com/microcontroladores-pic/pwm-modulacion-por-ancho-
depulso/#:~:text=El%20m%C3%B3dulo%20PWM%20(Pulse%20Width,resoluci%C3%B3n%2
0m%C3%A1xima%20de%2010%20BITS.
Reactivo 2.
AMBATO-ECUADOR
Para configurar el módulo CCP se utiliza la sentencia :

a set_pwmx_duty(valor);
b setup_ccpx(CCP_OF);
c setup_ccpx(CCP_CAPTURE_RE);
d setup_ccpx(modo);
a) set_pwmx_duty(valor);
b) setup_ccpx(CCP_OF);
c) setup_ccpx(CCP_CAPTURE_RE);
d) setup_ccpx(modo);.
Respuesta correcta: d)
Justificación:
Para configurar el módulo CCP:
setup_ccpx(modo);
Donde modo hace referencia a los bits CCPxM3:CPxM0 del registro CCPxCON y en PIC C
puede ser configurado según la siguiente tabla:

https://controlautomaticoeducacion.com/microcontroladores-pic/pwm-modulacion-por-ancho-
depulso/#:~:text=El%20m%C3%B3dulo%20PWM%20(Pulse%20Width,resoluci%C3%B3n%2
0m%C3%A1xima%20de%2010%20BITS
Reactivo 3.
La comunicación UART o comunicación serial utiliza varias líneas que son :

a) RX, TX, GND
b) RX,TX
c) EN , STATE, GND
d) VCC , GND, TX
a) RX, TX, GND
b) RX,TX
c) EN , STATE, GND
d) VCC , GND, TX
Respuesta correcta: a)
AMBATO-ECUADOR
Justificación:
La comunicación UART o comunicación serial sólo utiliza tres líneas: una para recibir los datos
Rx, otra para trasmitir los datos Tx y la línea común GND.
https://controlautomaticoeducacion.com/microcontroladores-pic/16-comunicacion-serial-con-
pic/
Reactivo 4.
El SPI es un protocolo síncrono que trabaja en modo ________:

a) Símplex
b) half – dúplex
c) full – dúplex
a) Símplex
b) half – dúplex
c) full – dúplex
Respuesta correcta: c)
Justificación:
El SPI es un protocolo síncrono que trabaja en modo full duplex para recibir y transmitir
información, permitiendo que dos dispositivos pueden comunicarse entre sí al mismo tiempo
utilizando canales diferentes o líneas diferentes en el mismo cable. Al ser un protocolo síncrono
el sistema cuenta con una línea adicional a la de datos encarga de llevar el proceso de
sincronismo.
http://panamahitek.com/como-funciona-el-protocolo-spi/
Reactivo 5.
Los módulos RF trabajan con el tipo de comunicación ________:

a) Símplex
b) half – dúplex
c) full – dúplex
a) Símplex
b) half – dúplex
c) full – dúplex
Respuesta correcta: C) Simplex
Justificación:
Los módulos RF de 433Mhz son muy populares por su bajo costo y fácil uso. Vienen en pareja,
emisor (FS1000A) y receptor (XY-MK-5V), el tipo de comunicación es simplex, es decir en un
solo canal y unidireccional, son de baja velocidad de transmisión, pero para aplicaciones básicas
son muy útiles.
AMBATO-ECUADOR
https://naylampmechatronics.com/blog/32_comunicacion-inalambrica-con-modulos-de-rf-
de.html

Reactivo 1.
1 NodeMCU A Un firmware de código abierto con servicio gratuito en la nube.
2 MicroPython B Un Firmware basado en Lua.

3 Mongoose C Una implementación de Python para dispositivos embebidos a la
plataforma ESP8266
a. 1A, 2B, 3C
b. 1B, 2C, 3A
c. 1C, 2A, 3B
d. 1A, 2C, 3B
Justificación:
• NodeMCU: un firmware basado en Lua.

• MicroPython: una implementación de Python para dispositivos embebidos a la plataforma
ESP8266.
• Mongoose Firmware: Un firmware de código abierto con servicio gratuito en la nube.
G. Acosta, «Aprendiendo Arduino,» 12 Noviembre 2016. [En línea]. Available:

https://aprendiendoarduino.wordpress.com/2016/11/12/wifi-en-arduino/.[Último acceso: 23
Noviembre 2020].
Reactivo 2.
conexiones ……… sencillas utilizando comandos de tipo ………
a HTPP-ALTEK
b UPM-Hayes
c TCP/IP-Hayes
d UHM-Hayes

AMBATO-ECUADOR
Justificación:
conexiones TCP/IP sencillas utilizando comandos de tipo Hayes.
L. d. V. Hernandez, «Programarfacil,» 19 Junio 2016. [En línea]. Available:
https://programarfacil.com/podcast/esp8266-wifi-coste-arduino/#Que_es_el_ESP8266. [Último
acceso: 23 Noviembre 2020].
Reactivo 3.
Es un contenedor de ……….. perfectamente aislado que puede ejecutar sus propios sistemas
operativos y aplicaciones como si fuera un ……….. físico.
a Software – ordenador
b Dispositivos – equipo
c Sistemas - ordenador
d Software – sistema
Justificación:
Es un contenedor de software perfectamente aislado que puede ejecutar sus propios sistemas
operativos y aplicaciones como si fuera un ordenador físico. Una máquina virtual se comporta
exactamente igual que lo hace un ordenador físico y contiene sus propios CPU, RAM, disco duro y
tarjetas de interfaz de red virtuales.
«GoogleSites,»11092019.[Enlínea].Available:
https://sites.google.com/view/instalaconfigurasw/investigaciones/manejo-de-maquina-virtuales.
[Último acceso: 30 11 2020]
AMBATO-ECUADOR
Reactivo 4.
Mosquitto es un ………. MQTT OpenSource ampliamente utilizado debido a su ligereza lo que

nos permite, fácilmente, emplearlo en gran número de ambientes, incluso si éstos son de pocos
recursos. Permite crear un primer ……… y subscriptor siguiendo para ello una jerarquía de un
……….
a Software – emisor – edificio.
b Broker – emisor – edificio.
c Broker – emisor – árbol.
d Broker – receptor – edificio.
9. Proceso de programación HDL y VHDL.
Reactivo 1.
1 Arquitectura A Es un lenguaje de descripción de circuitos

electrónicos digitales que utiliza distintos
niveles de abstracción.
2 Entidad B Describe el funcionamiento de la entidad a la
que hace referencia.
3 VHDL C Es la abstracción de un circuito, ya sea desde
un complejo sistema electrónico o una simple
puerta lógica.
m) 1A, 2B, 3C
n) 1B, 2C, 3A
o) 1C, 2A, 3B
p) 1A, 2C, 3B
Justificación:
• VHDL: VHDL es un lenguaje de descripción de circuitos electrónicos digitales que
utiliza distintos niveles de abstracción. El significado de las siglas VHDL es VHSIC
(Very High Speed Integrated Circuits) Hardware Description Language.
AMBATO-ECUADOR
• Entidad: Una entidad es la abstracción de un circuito, ya sea desde un complejo sistema

electrónico o una simple puerta lógica. La entidad únicamente describe la forma externa
del circuito, en ella se enumeran las entradas y las salidas del diseño.
• Arquitectura: Una arquitectura describe el funcionamiento de la entidad a la que hace
referencia, es decir, dentro de architecture se tiene que describir el funcionamiento de la
entidad a la que está asociada utilizando las sentencias y expresiones propias de VHDL.

M. Sánchez-Élez, INTRODUCCIÓN A LA PROGRAMACIÓN EN VHDL, Madrid: Española,
2008.
Reactivo 2.
Estructura Básica de un Archivo fuente en VHDL: ________ y ________.
a Texto y Fuente
b Entidad y Fuente
c Entidad y Estructura
d Estructura y Datos

Justificación:
Estructura Básica de un Archivo fuente en VHDL Como hemos visto los modelos VHDL están
formados por dos partes: la entidad (entity) y la arquitectura (architecture); es en esta última
donde se escriben las sentencias que describen el comportamiento del circuito, a este modelo de
programación en VHDL se le suele denominar behavioral.
Nivel de dificultad: Alto
2008.
Reactivo 3.
Enunciado. – Verdadero o Falso
AMBATO-ECUADOR
LAN server es un protocolo que no permite crear una interfaz web a través de
cuatro herramientas importantes: servidor de apache, My sql y php todos estos en
base al sistema operativo Linux.
a Verdadero
b Falso
Opciones de Respuesta: De la opción “a” hasta la opción “b”.

Justificación:
LAN server es un protocolo que permite crear una interfaz web a través de cuatro herramientas
importantes: servidor de apache, My sql y php todos estos en base al sistema operativo Linux.
J. Arias, Extension de red con LAN SERVER, Ambato: Universidad Tecnica de Ambato, 2020.
Reactivo 4.
Enunciado. – Seleccione los pasos para la creación de una base de datos en My sql
A. crear una tabla donde se definirá cierta cantidad de columnas.
B. Crear un usuario.
C. Generar una contraseña.
D. Cada columna debe tener su identificador Id.
E. exportar datos se lo podrá hacer mediante una tabla de Excel transformado
a .cvs” delimitado por comas”.
a A-B-C
b A-B-D
c A-D-E
d A-C-D

Justificación:
➢ Base de datos:
✓ La base de datos fue creada en base a My sql, donde debemos considerar los
siguientes puntos:
✓ Debemos crear una tabla donde se definirá cierta cantidad de columnas.
✓ Cada columna debe tener su identificador Id, (tipo de dato int double float etc),
longitud de valor entre otros.
✓ Si queremos exportar datos se lo podrá hacer mediante una tabla de Excel
transformado a .cvs” delimitado por comas”.
AMBATO-ECUADOR
✓ En My sql se debe tomar en cuenta que cada versión trabajo o con puntos o con
comas.
J. Arias, Extension de red con LAN SERVER, Ambato: Universidad Tecnica de Ambato, 2020.
10. Metodos Y Metodologia de Diseño de VHDL

Reactivo 1
La descripción ………….. está basada dentro de un bloque de arquitectura donde la descripción
es un poco más larga y menos clara ya que el cuerpo de la arquitectura está compuesto por un
……….., es decir se ponen los componentes e interconexiones, para los cuales se utilizarán
…………. que ya están definidas en la biblioteca.
a Estructural; entrada; entidades
b Comportamental; salida; controles
c Comportamental; netlist; controles
d Estructural; netlist; entidades
Justificación:
La descripción estructural está basada dentro de un bloque de arquitectura donde la descripción
es un poco más larga y menos clara ya que el cuerpo de la arquitectura está compuesto por un
netlist, es decir se ponen los componentes e interconexiones, para los cuales se utilizarán
entidades que ya están definidas en la biblioteca.
11. DESARROLLO POR TEMAS

Reactivo 1.
Muestra una representación del diseño pre-optimizado en términos de símbolos genéricos como:
sumadores, multiplicadores, contadores, compuertas AND y OR
a Modelado Technology
b Modelado RTL
c Arquitectura
d Entorno de simulación
Justificación: Modelado RTL Muestra una representación del diseño pre-optimizado en
términos de símbolos genéricos como: sumadores, multiplicadores, contadores, compuertas
AND y OR
Fuente de verificación: Libro VHDL Lenguaje para síntesis y modelado de circuitos de
Fernando Pardo y José A.
Reactivo 2
Consiste en la declaración que se le asigne permitiendo la definición de la función del circuito
AMBATO-ECUADOR
que se empleará y contendrá siempre una entidad concreta, así que las declaraciones sin
especificar su entidad no las tomará en consideración.
a Comportamental
b Estructural
c Arquitectura
d Top-Down
Justificación:
La Arquitectura consiste en la declaración que se le asigne permitiendo la definición de la
función del circuito que se empleará y contendrá siempre una entidad concreta, así que las
declaraciones sin especificar su entidad no las tomará en consideración.
Fuente de verificación: Xilinx FPGAs Using ISE Design Suite, Libro Dye David Capitulo
3, página 58.
Reactivo 2.
Enunciado. - Selecciones la respuesta correcta.
Para la creacion del codigo funcional de un módulo VHDL debe consistir de:
a Declaración bibliotecas, Entidad, Arquitectura

b Modelo, Entidad, Arquitectura
c Plantillas, Modelo, Arquitectura
d Entorno, Entidad, Arquitectura
Justificación: Para la creacion del codigo funcional de un módulo VHDL debe consistir de
Declaración bibliotecas, Entidad, Arquitectura
Baldeon.
Reactivo 3
Enunciado. – Completar con la respuesta correcta
El diseño __________ es, en su más pura forma, el proceso de capturar una idea en un alto nivel
de__________, e implementar esa idea primero en un muy _________nivel
a Bottom UP – detección – bajo
b Metodología – diseño – alto
c Top_Down – abstracción – alto.
d Sistema – materialización – alto
3, página 41.
Reactivo 3.
Un banco de pruebas es un código ….....que permite proporcionar un conjunto de estímulos

AMBATO-ECUADOR
…................y …..............además de que es portátil en diferentes simuladores
a VHDL, documentados, repetibles

b VHDL, Entornos, repetibles
c HDL, documentados, repetibles
d HDL, documentados, secuenciales.
Justificación:
Bottom UP: El diseño Top_Down es, en su más pura forma, el proceso de capturar una idea en
un alto nivel de abstracción e implementar esa idea primero en un muy alto nivel
Nivel de dificultad: Difícil
Fuente de verificación: Metodología de Diseño y modelado de circuitos en VHDL de Ayala
Carlos Alberto González.
Reactivo 4
La entidad únicamente describe la forma externa del ………….., en ella se enumeran las
entradas y las salidas del ………….
a circuito / diseño
b diseño / circuito
c código / programa
d sistema / circuito
Justificación:
La entidad únicamente describe la forma externa del circuito, en ella se enumeran las entradas y
las salidas del diseño.
Justificación: Un banco de pruebas es un código HDL que permite proporcionar un
conjunto de estímulos documentados y repetibles además de que es portátil en diferentes
simuladores.
Fuente de verificación: Estructura de VHDL, Sitio Web Barragan Diego, página 6.
Reactivo 4.
AMBATO-ECUADOR
El modelo Technology al visualizar este esquema nos permite ver una representación a nivel
tecnológico de su ..............optimizada para una arquitectura ….....específica, que podría
ayudar a descubrir problemas de .........al principio del proceso de diseño.
a VHDL, Xilinx, codificación

b HDL, Xilinx, simulacion
c VHDL, Xilinx, visualización
d HDL, Xilinx, diseño.
Justificación: Al visualizar este esquema nos permite ver una representación a nivel
tecnológico de su HDL optimizada para una arquitectura Xilinx específica, que podría
ayudar a descubrir problemas de diseño al principio del proceso de diseño.
Fuente de verificación: Introducción a la programación en VHDL - Marcos Sánchez-Élez
3, página 64.
Reactivo 1.
¿Cuál es la información que contiene el atributo EVENT y su propósito?
a Cambios en una señal de entrada y su uso es necesario para propósitos de ejecución del
RTL squematic.
b Eventos de señales de entrada especificados dentro de la entidad para propósitos de
simulación.
c Cambios de una señal y su uso es necesario para propósitos de simulación.
d Cambios de señales de entrada especificados dentro de la arquitectura para propósitos de
configuración.
Justificación: El atributo mas usado es EVENT, en donde el driver lleva información de los
cambios de una señal y su uso es necesario para propósitos de simulación.
Nivel de dificultad: Fácil
3, página 58.
Reactivo 2.
AMBATO-ECUADOR
En una descripción estructural, los componentes se comunican entre si a través de señales, por lo
que:
a La instanciación de componentes es una proposición básica en una arquitectura

comportamental.
b La instanciación de componentes es una proposición básica en una arquitectura estructural.
c Los componentes deben ser instanciados en la descripción comportamental.
d Los componentes deben ser instanciados en la arquitectura .
Justificación: En una descripción estructural, los componentes se comunican entre si a

través de señales. Un componente puede ser un sistema individual especificado por medio
de su Entidad y Arquitectura por lo que La instanciación de componentes es una proposición
básica en una arquitectura estructural.
3, página 41.
Reactivo 3.
En la instanciaciónón por ............, la lista de conexiones se hace en el mismo orden en que los
puertos fueron ............... en la entidad del ..........................
a posición, declarados, componente instanciado

b componentes, declarados, componente repetible
c posicion, declarados, componente dado
d posicion, documentados, componente secuencial.
Justificación: En la instanciaciónón por posición, la lista de conexiones se hace en el mismo

orden en que los puertos fueron declarados en la entidad del componente instanciado. Se
aconseja el uso de asociación por nombre, ya que es menos propensa a errores.
Fuente de verificación: Estructura de VHDL, Sitio Web Barragan Diego, página 86.
AMBATO-ECUADOR
Reactivo 4.
En el PORT MAP los puertos en una declaración de componente generalmente deben

coincidir con los puertos en la declaración de entidad uno por uno. La declaración del
componente define los …......., el …...., el modo y los tipos de puertos que se utilizarán
cuando el componente se instale en el cuerpo de la ….........
a nombres, el orden, estructura

b nombres, el modelo, arquitectura
c nombres, el orden, arquitectura
d atributos, el orden, arquitectura
Justificación: Los puertos en una declaración de componente generalmente deben coincidir

con los puertos en la declaración de entidad uno por uno. La declaración del componente
define los nombres, el orden, el modo y los tipos de puertos que se utilizarán cuando el
componente se instale en el cuerpo de la arquitectura.
3, página 64.
Reactivo 1
En VHDL la parte exterior es decir cuántos puertos de entrada y salida tenemos se denomina
………..y la descripción del comportamiento del circuito de denomina …………..
a Entity; architecture
b Architecture; entity
c Estados; transiciones
d Transiciones; modelado estructural
Justificación:
Un detector de secuencia de Mealy realiza un análisis de todos sus estados para identificar tanto la
secuencia correcta o incorrecta, dentro de esta puede existir dos la forma continua y segmentada
estos dos tipos de soluciones se diferencia por los estados que va a desarrollos ya que en la
segmentada tiene más estados que la continua.
Fuente de verificación: Libro Introducción a la Programación en VHDL de Marcos Sánchez Élez.
[3]
AMBATO-ECUADOR
Reactivo 3
¿Qué es Port Map y para que se lo usa?
a Es una cláusula que realiza declaraciones globales.
b Es una cláusula que realiza descripciones estructurales.
c Es una cláusula que realiza descripciones comportamentales
d Es una cláusula que realiza llamados a un nivel jerarquico.
Justificación:
La cláusula PORT MAP declara las conexiones. Si PORT fuera una declaración local, PORT MAP
sería una forma de declaración global. En realidad, cada instanciación de un componente puede ser
vista como una llamada a su proceso y, por tanto, a una sentencia concurrente como sucedía en el
modelado comportamental. Si la instancia es también una descripción estructural, llamará a los
procesos correspondientes de un nivel jerárquico inferior y así sucesivamente hasta encontrar algún
modelo comportamental puro.

Fuente de verificación: “Apuntes de VHDL” de Rafael Rico [4]
Reactivo 4
Enunciado. - Seleccione el orden correcto
Cada sentencia pertenece a una definición:
1. IN
2. OUT
3. INOUT
4. BUFFER
5. LINKAGE
a. Tipo extendido de salida.

b. Para indicar que la señal es una entrada o salida dependiendo de cada instante.
c. Para indicar que la señal es una entrada
d. Para indicar que la señal es una salida
e. Es un tipo enlace genérico de salida que está en desuso. La norma vaticina su desaparición.
AMBATO-ECUADOR
Respuestas:
a 1.A; 2.D; 3.C; 4.B; 5.E
b 1.C; 2.D; 3.A; 4.B; 5.E
c 1.C; 2.A; 3.D; 4.B; 5.E
d 1.C; 2.D; 3.B; 4.A; 5.E
Justificación:
Una señal IN recibe sus valores desde el exterior de la entidad.

Una señal OUT genera valores al exterior de la entidad.
Una señal INOUT puede ser asignada en ambos sentidos y es responsabilidad del diseñador
determinar en qué condiciones de la función lógica descrita la señal puede ser IN o OUT.
Una señal BUFFER es señal de salida directamente asignable a otra señal dentro de la arquitectura,
pero no puede ser forzada desde el exterior, dicho de otra manera, no es en ningún momento una
entrada.

Fuente de verificación: “VHDL para diseño y validación de sistemas digitales” [5]
Reactivo 5
Enunciado. – Complete correctamente el enunciado
La declaración de ……… proporciona información sobre la interfaz externa de un
componente, que incluye los puertos de entrada y salida y los ……. La información es similar
al proporcionado en una declaración de entidad.
a Puertos – componentes.
b Un vector – buffers.
c Componente - parámetros relevantes.
d Componente – parámetros auxiliares.
Justificación:
La declaración de componente proporciona información sobre la interfaz externa de un

componente, que incluye los puertos de entrada y salida y los parámetros relevantes. La
información es similar al proporcionado en una declaración de entidad.
Fuente de verificación: “RTL hardware design using VHDL” [6]
Ejercicios Taller
Reactivo 1.
Enunciado. – Seleccione la respuesta correcta:
Sentencias Concurrentes:
a Las sentencias concurrentes son sentencias condicionales que tienen al menos dos
valores por defecto para cuando no se cumplen ninguna de las condiciones.
AMBATO-ECUADOR
b Las sentencias concurrentes son sentencias condicionales que tienen al menos un

valor por defecto para cuando no se cumplen ninguna de las condiciones.
c Las sentencias concurrentes son sentencias condicionales que tienen al menos tres
valores por defecto para cuando no se cumplen ninguna de las condiciones.
d Las sentencias concurrentes son sentencias condicionales que no tienen un valor
por defecto.
Respuesta correcta: b) Las sentencias concurrentes son sentencias condicionales que tienen al
menos un valor por defecto para cuando no se cumplen ninguna de las condiciones.
Justificación:
Las sentencias concurrentes son sentencias condicionales que tienen al menos un valor por defecto
para cuando no se cumplen ninguna de las condiciones. Aunque podría utilizarse una sentencia
común como un if con obligación de else, los desarrolladores de VHDL han preferido utilizar dos
sentencias particulares:

Fuente de verificación: (Introducción A La Programación En VHDL, Marcos Sánchez, pág. 19)
Reactivo 2.
¿Qué metodología usa normalmente un testbench?
a Espera de tiempo, creación de estímulos y comprobación de resultados.
b Creación de estímulos, comprobación de resultados y espera de tiempo.
c Creación de estímulos, espera de tiempo y comprobación de resultados.
d Creación de estímulos, espera de tiempo sólo si se está probando un circuito
síncrono y comprobación de resultados.
Respuesta correcta: c) Creación de estímulos, espera de tiempo y comprobación de resultados.
Justificación:
La Fase de simulación se ejecuta de una forma particular, primero define o crea los estímulos
correspondientes, luego aplica una espera de tiempo y finalmente muestra los resultados obtenidos
mediante una gráfica o datos.
Fuente de verificación: (Introducción A La Programación En VHDL, Marcos Sánchez, pag. 39)
Reactivo 3.
VHDL presenta una sentencia específica, WAIT, que detiene la ejecución del código
hasta que se cumpla una condición. ¿Cuándo debe aparecer obligatoriamente la sentencia
WAIT?
a La sentencia wait debe aparecer obligatoriamente si el process no tiene lista de
sensibilidad
AMBATO-ECUADOR
b La sentencia wait debe aparecer obligatoriamente si el process tiene lista de

sensibilidad
c La sentencia wait debe no aparecer
d La sentencia wait debe aparecer obligatoriamente siempre
Respuesta correcta: a) La sentencia wait debe aparecer obligatoriamente si el process no tiene
lista de sensibilidad
Justificación:
VHDL presenta una sentencia específica, WAIT, que detiene la ejecución del código hasta que se
cumpla una condición. La sentencia wait debe aparecer obligatoriamente si el process no tiene lista
de sensibilidad.
Reactivo 4.
En que consiste la Fase 0 de simulación:

a La simulación comienza en la fase de inicialización donde a las señales se les
asignan unos valores iniciales y se pone el tiempo a cero. La asignación se hace
rellenando una lista de eventos para el instante t = 0.
b todas las transiciones planificadas para ese tiempo son ejecutadas. Es decir, se
ejecuta el código ordenadamente teniendo en cuenta cuales son las señales que
se han modificado, cumpliendo las normas de ejecución explicadas para los
process.
c Las señales que se han modificado como consecuencia de las transiciones
planificadas en el instante t se escriben en la lista de eventos planificándose para
el instante t + δ. Donde δ es un instante infinitesimal.
d La simulación comienza en la fase de inicialización donde a las señales se les
asignan unos valores iniciales y se pone el tiempo a cero. La asignación se hace
rellenando una lista de eventos para el instante t = 1.
Respuesta correcta: a) La simulación comienza en la fase de inicialización donde a las señales se

les asignan unos valores iniciales y se pone el tiempo a cero. La asignación se hace rellenando una
lista de eventos para el instante t = 0.
Justificación:
La simulación consta de tres fases:
- Fase 0: la simulación comienza en la fase de inicialización donde a las señales se les asignan unos
valores iniciales y se pone el tiempo a cero. La asignación se hace rellenando una lista de eventos
para el instante t = 0.
- Fase 1: todas las transiciones planificadas para ese tiempo son ejecutadas. Es decir, se ejecuta el
código ordenadamente teniendo en cuenta cuales son las señales que se han modificado,
cumpliendo las normas de ejecución explicadas para los process.
- Fase 2: Las señales que se han modificado como consecuencia de las transiciones planificadas en
el instante t se escriben en la lista de eventos planificándose para el instante t + δ. Donde δ es un
instante infinitesimal.
Fuente de verificación: (Introducción A La Programación En VHDL, Marcos Sánchez, pág. 35)
AMBATO-ECUADOR
Reactivo 5.
A que hace referencia la siguiente descripción:
Esta descripción utiliza para la creación de la arquitectura de la entidad entidades descritas

y compiladas previamente, de esta manera en VHDL podemos aprovechar diseños ya
realizados, o realizar diseños sabiendo que se utilizarán en otros más complicados. Así se
ahorra trabajo al diseñador-programador.
a Descripción Comportamental
b Descripción Estructural
c No corresponde a ninguna descripción.
d Descripción por Estados.
Respuesta correcta: b) Descripción Estructural
Justificación:
Descripción Estructural
Esta descripción utiliza para la creación de la arquitectura de la entidad entidades descritas y
compiladas previamente, de esta manera en VHDL podemos aprovechar diseños ya realizados, o
realizar diseños sabiendo que se utilizarán en otros más complicados. Así se ahorra trabajo al
diseñador-programador. Se declaran los componentes que se van a utilizar y después, mediante los
nombres de los nodos, se realizan las conexiones entre los puertos. Las descripciones estructurales
son útiles cuando se trata de diseños jerárquicos botton-up.
REACTIVO 1.
1 Arquitectura A Es un lenguaje de descripción de circuitos

electrónicos digitales que utiliza distintos niveles
de abstracción.
2 Entidad B Describe el funcionamiento de la entidad a la
que hace referencia.
3 VHDL C Es la abstracción de un circuito, ya sea desde un
complejo sistema electrónico o una simple
puerta lógica.
q) 1A, 2B, 3C
r) 1B, 2C, 3A
s) 1C, 2A, 3B
t) 1A, 2C, 3B
AMBATO-ECUADOR
Justificación:
• VHDL: VHDL es un lenguaje de descripción de circuitos electrónicos digitales que utiliza
distintos niveles de abstracción. El significado de las siglas VHDL es VHSIC (Very High Speed
Integrated Circuits) Hardware Description Language.
• Entidad: Una entidad es la abstracción de un circuito, ya sea desde un complejo sistema
electrónico o una simple puerta lógica. La entidad únicamente describe la forma externa del
circuito, en ella se enumeran las entradas y las salidas del diseño.
• Arquitectura: Una arquitectura describe el funcionamiento de la entidad a la que hace
referencia, es decir, dentro de architecture se tiene que describir el funcionamiento de la
entidad a la que está asociada utilizando las sentencias y expresiones propias de VHDL.

2008.
Reactivo 2.
Estructura Básica de un Archivo fuente en VHDL: ________ y ________.
a Texto y Fuente
b Entidad y Fuente
c Entidad y Estructura
d Estructura y Datos
a) Texto y Fuente
b) Entidad y Fuente
c) Entidad y Estructura
d) Estructura y Datos
Justificación:
Estructura Básica de un Archivo fuente en VHDL Como hemos visto los modelos VHDL están
formados por dos partes: la entidad (entity) y la arquitectura (architecture); es en esta última
donde se escriben las sentencias que describen el comportamiento del circuito, a este modelo de
programación en VHDL se le suele denominar behavioral.
AMBATO-ECUADOR

2008.
Reactivo 3.
Enunciado. – Verdadero o Falso
LabVIEW ofrece un enfoque de programación gráfica que le ayuda a visualizar

cada aspecto de su aplicación, incluyendo configuración del hardware, datos de
medidas y depuración.
a Verdadero
b Falso
a) Verdadero
b) Falso
Justificación:
LabVIEW ofrece un enfoque de programación gráfica que le ayuda a visualizar cada aspecto de
su aplicación, incluyendo configuración del hardware, datos de medidas y depuración. Esta
visualización simplifica la integración del hardware de medidas de cualquier proveedor,
representa una lógica compleja en el diagrama, desarrolla algoritmos de análisis de datos y
diseña interfaces de usuario de ingeniería personalizadas
J. Arias, Extension de red con LAMP SERVER, Ambato: Universidad Tecnica de Ambato, 2020.
Reactivo 4.
National Instruments (NI) es una empresa que transforma la manera en cómo los _________ e
investigadores ________, generan prototipos e implementan sistemas para aplicaciones
embebidas, de medidas y de automatización
a Ingenieros - diseñan
b Informáticos - científicos
c Módulos - Estructura
d Ingenieros - recolectan
a) Ingenieros - diseñan
b) Informáticos - científicos
c) Módulos – Estructura
d) Ingenieros - recolectan
AMBATO-ECUADOR
Justificación:
National Instruments (NI) es una empresa que transforma la manera en cómo los ingenieros e
investigadores diseñan, generan prototipos e implementan sistemas para aplicaciones
embebidas, de medidas y de automatización. El objetivo de esta empresa es que sus clientes
desarrollen continuamente tecnologías innovadoras que impacten a millones de personas ya sea
desde la programación de sistemas de juegos de la próxima generación hasta la creación de
nuevos dispositivos médicos
J. Arias, Extension de red con LAMP SERVER, Ambato: Universidad Tecnica de Ambato, 2020.
AMBATO-ECUADOR
9. BIBLIOGRAFÍA
[1] T. L. Floyd, Fundamentos de Sistemas Digitales, Madrid: Pearson, 2006.

[2] M. Alavi, S. Aliaga and M. Murga, "Máquinas de Estado Finito Finite State Machines," Revistas
Bolivianas, vol. 8, pp. 41-57, 2016.
[3] N. Malpica, "Síntesis de circuitos secuenciales síncronos: Máquinas de estados finitos," 2014.
[4] G. Bosque Pérez and P. Rodriguez, Principios de Diseño de Sistemas Digitales, Servicio Editorial de la
Universidad del País Vasco, 2016.
[5] R. J. Tocci, Sistemas Digitales Principios y Aplicaciones, Mexico: Pearson, 2007.
[6] C. Borbon, "FundéuRAE," FundéuRAE, 04 02 2011. [Online]. Available:
https://www.fundeu.es/recomendacion/sincronicosincrono/.
[7] R. A. Española, "Real Academia Española," Real Academia Española, [Online]. Available:
https://dle.rae.es.
[8] Setup, "SETUP," [Online]. Available: http://www.set-up.es/la-senal-de-reloj/.
[9] privarsa, "Privarsa," [Online]. Available: https://www.privarsa.com.mx/producto/contador-de-ciclos/.
[10] "Aprendiendo Arduino," [Online]. Available:
https://aprendiendoarduino.wordpress.com/2016/11/16/zigbeexbee/. [Accessed 22 Noviembre 2020].
[11] "CodigoElectronica," 2017. [Online]. Available: http://codigoelectronica.com/blog/introduccion-a-pic-
c-compiler. [Accessed 2020].
[12] "Modos de Transmisión (Simplex, Half y Full Duplex)," [Online]. Available:
http://cidecame.uaeh.edu.mx/lcc/mapa/PROYECTO/libro27/35_modos_de_transmisin_simplex_half_y
_full_duplex.html. [Accessed 22 Noviembre 2020].
[13] S. A. C. Giraldo, "PWM con PIC – (Modulación por Ancho de Pulso)," [Online]. Available:
https://controlautomaticoeducacion.com/microcontroladores-pic/pwm-modulacion-por-ancho-de-
pulso/#:~:text=El%20m%C3%B3dulo%20PWM%20(Pulse%20Width,resoluci%C3%B3n%20m%C3%
A1xima%20de%2010%20BITS.. [Accessed 21 Noviembre 2020].
[14] "bluetooth," [Online]. Available: https://definicion.de/bluetooth/. [Accessed 22 Noviembre 2020].
[15] D. F. Blanca, "HDL," [Online]. Available: http://oa.upm.es/48895/. [Accessed 13 12 2020].
[16] M. Sánchez-Élez, "INTRODUCCIÓN A LA PROGRAMACIÓN VHDL," [Online]. Available:
https://eprints.ucm.es/26200/1/intro_VHDL.pdf. [Accessed 13 12 2020].
[17] Sedici, "Metodologías de diseño de hardware en VHDL," [Online]. Available:
http://sedici.unlp.edu.ar/bitstream/handle/10915/3835/2_-
_Metodolog%C3%ADas_de_dise%C3%B1o_de_hardware.pdf?sequence=4&isAllowed=y. [Accessed
13 12 2020].
[18] E. Nevada, "SUBSISTEMA," Septiembre 2019. [Online]. Available:
https://tgs.fandom.com/es/wiki/Subsistema#:~:text=Un%20subsistema%20es%20un%20sistema,parte
%20de%20un%20sistema%20superior..
[19] S. E. Tropea, "Test benches," Copyright, 2011. [Online]. Available:
http://fpgalibre.sourceforge.net/testbenches/intro-
concepto.html#:~:text=1.2.,el%20funcionamiento%20de%20un%20dispositivo..
[20] R. S. Fernandez, "Sintecis de un Procesador en VHDL para su posterior volcado en una FPGA," España
, 2017.
[21] microensamble SAS, "Netlist," 2018. [Online]. Available: http://microensamble.com/glosario/netlist/.
[22] V. R. González, "Programación estructurada," CFIE Valladolid II, España, 2015.
AMBATO-ECUADOR
[23] VHDL. Lenguaje de descripción hardware, Universidad de Alicante, 2007.

[24] N. Zainalabedin, VHDL: Análisis y modelado de sistemas digitales, McGraw-Hill, Inc, 1997.
[25] D. Dye, Xilinx FPGAs Using ISE Design Suite, 2012.
[26] M. J. Mathieu, Introducción a la programación, Mexico: Patria, 2004.
[27] D. Barragan, Estructura de VHDL, 2015.
[28] N. Malpica, Máquinas de estados finitos, España, 2015.
[29] T. L. Floyd, Fundamentos de sistemas digitales, Madrid: Pearson Educación S. A., 2006.
[30] A. "ARDUINO IDE," 2020. [Online]. Available: https://www.arduino.cc/en/contact-us. [Accessed 27
10 2020].
[31] P. "Curso Arduino," 14 07 2016. [Online]. Available: http://cursoarduino.proserquisa.com/wp-
content/uploads/2016/10/Tutorial-1-Introduccion-a-Arduino.pdf.. [Accessed 27 10 2020].
[32] G. H. "Arduino," Halley, 2014.
[33] S. Reinoso, L. Mena and M. P, "Programacion de microcontroladores PIC con Lneduaje C,"
Universidad de las Fuerzas Armadas ESPE, Sangolqui-Ecuador, 2018.
[34] I. C, "CCS C Compiler Manual," Copyright Custom Computer Services, 2019.
[35] E. Garcia Breijo, "Microcontroladores de Compilador C CCS y Simuldor proteus para
microcontroladores PIC," Mrcombo, España, 2019.
[36] Y. Fernandez, "Que es Arduino, como funciona y que puedes hacer con uno," Xataka Basics, 2020.
[37] A. Canovas Lopez, "Manual de Usuario del compilador PCW de CCS," Compiler for Microchip Pic
Micro, [Online]. Available: http://www.cursos.ucv.cl/eie48700/referencias/CCS_C_Manual.pdf.
[38] D. Apaza Condori, "Microcontroladores PIC - Fundamentos y aplicaciones un enfoque didactico,"
Microchip, Sn Francisco, 2010.
[39] I. Betancur and P. Yazmin, Guia practica en lenguaje C para microcontroladores PIC 16F87X usando
interfaz CCS C y el simulador Proteus, Colombia - Pereira: Universidad Tecnologica de Pereira, 2017.
[40] I. Cuadros Acosta, "Archivo Hex de Arduino," Geek Electronica, 2015.
[41] I. Delgado, "¿Qué es la comunicacion?," 11 09 2020. [Online]. Available:
https://www.significados.com/comunicacion/. [Accessed 21 11 2020].
[42] E. Unicrom, "PWM – Modulación por Ancho de Pulso," [Online]. Available:
https://unicrom.com/pwm-modulacion-por-ancho-de-pulso/. [Accessed 21 Noviembre 2020].
[43] S. A. C. GIRALDO, "Comunicación Serial con PIC," [Online]. Available:
https://controlautomaticoeducacion.com/microcontroladores-pic/16-comunicacion-serial-con-pic/.
[Accessed 22 Noviembre 2020].
[44] E. G. Breijo, "Compilador C CCS y Simulador Proteus para Microcontroladores PIC," 2017. [Online].
Available: https://controlautomaticoeducacion.com/microcontroladores-pic/comunicacion-i2c/.
[45] Corporativo, "Especificaciones de Philips sobre el bus I2C," 2018. [Online]. Available: http://robots-
argentina.com.ar/didactica/descripcion-y-funcionamiento-del-bus-i2c/.
[46] L. LLAMAS, "EL BUS I2C EN ARDUINO," 2016. [Online]. Available:
https://www.luisllamas.es/arduino-i2c/.
[47] L. LLAMAS, "COMUNICACIÓN INALÁMBRICA EN ARDUINO CON MÓDULOS RF 433MHZ,"
2016. [Online]. Available: https://www.luisllamas.es/comunicacion-inalambrica-en-arduino-con-
modulos-rf-433mhz/.
[48] A. Arduino, "bluetooth-en-arduino," wordpress, 2016. [Online]. Available:
https://aprendiendoarduino.wordpress.com/.
[49] candy-ho, "Programación inalámbrica de Arduino por bluetooth," Mexico, 2002.
[50] J. G. Navarro, "control de un modulo bluetooth mediante un microcontrolador," España , 2005.
[51] M. J. Gutiérrez, "Todo sobre ZigBee, la tecnología ultrabarata para comunicación inalámbrica," 10
Agosto 2015. [Online]. Available: https://elandroidelibre.elespanol.com/2015/08/todo-sobre-zigbee-la-
AMBATO-ECUADOR
tecnologia-ultrabarata-para-comunicacion-inalambrica.html. [Accessed 22 Noviembre 2020].

[52] B. Diaz, "esacademic," 2010. [Online]. Available: https://esacademic.com/dic.nsf/eswiki/561154.
[Accessed 02 12 2020].
[53] A. Carvajal, "Uniminuto," 2018. [Online]. Available:
https://www.researchgate.net/profile/Jonathan_Alvarez_Ariza/publication/327010126_Lenguaje_de_de
scripcion_de_hardware_VHDL/links/5b72337d299bf14c6d9c410f/Lenguaje-de-descripcion-de-
hardware-VHDL.pdf. [Accessed 03 12 2020].
[54] V. Isacar, "euloxio," 2013. [Online]. Available:
http://euloxio.myds.me/dok/elo/dig001/Tema16_Lenguajes-de-descripcion_Parte1.pdf. [Accessed 02
12 2020].
[55] R. Loaiza, "Universidad de Alicante," 2007. [Online]. Available:
https://rua.ua.es/dspace/bitstream/10045/3833/1/S2_1_VHDL_INTRODUCCION_HISTORIA.pdf.
[Accessed 02 12 2020].
[56] R. Sanz, "ETS," 2017. [Online]. Available:
http://oa.upm.es/48931/1/TFG_ROSA_SANZ_FERNANDEZ.pdf. [Accessed 02 12 2020].
[57] R. S. FERNÁNDEZ, "SÍNTESIS DE UN PROCESADOR EN VHDL," ETSI, Madrid , 2017.
[58] J. V. d. Spiegel, "Tutorial de VHDL," PENN Enginnering, Pennsylvania, 2001.
[59] S. Noriega, "Introducción al diseño lógico con VHDL," electrotecnia, 2017.
[60] E. S. Serafin Alfonso Perez, Diseño de sistemas digitales con VHDL, Thomson, 2002.
[61] M. Heredia, "frm," 17 05 2016. [Online]. Available:
http://www1.frm.utn.edu.ar/tecnicad1/_private/Apuntes/VHDL.pdf. [Accessed 02 12 2020].
[62] F. Muñoz, "Universidad de Sevilla," 10 2011. [Online]. Available:
file:///C:/Users/geova/Downloads/VHDL1_microE.pdf. [Accessed 02 12 2020].
[63] A. Aguirre, "researchgate," 12 09 2015. [Online]. Available:
https://www.researchgate.net/publication/39436651_VHDL_Estructura_basica. [Accessed 02 12 2020].
[64] L. Perez, "itq," 16 04 2016. [Online]. Available:
http://www.itq.edu.mx/carreras/IngElectronica/archivos_contenido/Apuntes%20de%20materias/Apunte
s_VHDL_2016.pdf. [Accessed 02 12 2020].
[65] D. Dye, Xilinx FPGAs Using ISE, Madrid, 2012.
[66] D. Barragan, "Estuctura de VHDL," 2015. [Online]. Available:
https://www.matpic.com/esp/descargas/vhdl_beamer/Clase_2_Estructura%20de%20VHDL.pdf.
[Último acceso: 17 Octubre 2020]..
[67] R. J. T. -. N. S. W. -. G. L. Moss, "dropbox," 2007. [Online]. Available:
https://www.dropbox.com/sh/c9goqd4fbnntf3k/AADQrXJvRkI6dGjYPLTO7d_2a/BOOK_Sistemas%2
0Digitales%20-%20Tocci.pdf?dl=0.
[68] "Conceptos Básicos EB," 2015. [Online]. Available:
http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/clases1/clases.htm#:~:text=Los%20atributos
%20son%20las%20caracter%C3%ADsiticas,valores%20distintos%20para%20estas%20variables..
[Accessed 21 Enero 2021].
[69] D. B. Guerrero, Diseño lógico secuencial con VHDL, Valparaiso: Argentina, 2012.
[70] "SoftwareSeleccion," 2000. [Online]. Available:
https://www.softwareseleccion.com/implantador/national+instruments-i-103. [Accessed 19 Enero
2021].
[71] L. Gómez, "Wikipedia," 2011. [Online]. Available: https://es.wikipedia.org/wiki/National_Instruments.
[72] "Wikipedia," 2015. [Online]. Available: https://es.wikipedia.org/wiki/LabVIEW. [Accessed 19 Enero
2021].
[73] N. Instruments, "N.I," 2016. [Online]. Available: https://www.ni.com/es-cr/shop/labview.html.
AMBATO-ECUADOR
[74] N. Instruments, "Zone NI," 12 11 2016. [Online]. Available: https://zone.ni.com/reference/en-

XX/help/370984T-
01/criodevicehelp/sbrio_concepts/#:~:text=An%20NI%20Single%2DBoard%20RIO,slots%20for%20C
%20Series%20modules.&text=The%20user%2Dreconfigurable%20FPGA%20controls,lines%20on%2
0the%20sbRIO%20device.. [Accessed 19 01 2021].
[75] U. d. P. Vasco, "ehu.eus," 12 Julio 2016. [Online]. Available: https://www.ehu.eus/es/web/tutorial-
myrio/sarrera.
[76] N. Instruments, "Ingenieria Extraordinaria," National Instruments Corp, 2019. [Online]. Available:
http://sine.ni.com/np/app/main/p/ap/imc/lang/es/pg/1/sn/n17:imc,n24:sbRIO/fmid/1240/#:~:text=Los%
20controladores%20Single%2DBoard%20RIO,productividad%20de%20un%20producto%20comercial.
.
[77] N. Instruments, "Engineer Ambitiously," [Online]. Available:
http://sine.ni.com/np/app/main/p/docid/nav-104/lang/es/fmid/12677/. [Accessed 20 Enero 2021].
[78] C. Nicolaou, "electronicsnotes," Incorporating radio electronics, 2017. [Online]. Available:
https://www.electronics-notes.com/articles/digital-embedded-processing/fpga-field-programmable-gate-
array/what-is-how-to-program-labview-fpga.php.
[79] "Wikipedia," 2016. [Online]. Available: https://es.wikipedia.org/wiki/LabVIEW. [Accessed 20 Enero
2021].
[80] M. Sánchez-Élez, INTRODUCCIÓN A LA PROGRAMACIÓN EN VHDL, Madrid: Española, 2008.
[81] J. Carrera, S. Contreras, F. Freire and B. Galarza, Grupo N°1 Ssistemas Embebidos, Universidad
Tecnica de Ambato, Ambato: Universidad Tecnica de Ambato, 2020.
[82] J. Arias, Extension de red con LAN SERVER, Ambato: Universidad Tecnica de Ambato, 2020.
[83] M. Sofia, Extension de red mediante uso de mosquitto Broker, Ambato: Universidad Tenica de Ambato,
2020.
[84] M. Sanchez, Introduccion a la programacion VHDL, Universidad de Madrid: Universidad de Madrid,
2016.
[85] S. Lopez, Introduccion al lenguaje de descricpion VHDL, Madrid: Universidad autonoma de Madrid,
2015.
[86] A. Freire, Introduccion al lenguaje VHDL, Madrid: Universidad politecnica de Madrid, 2013.

Sistemas Embebidos Resumen Octubre 2020 Febrero 2021

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Sistemas Embebidos Resumen Octubre 2020 Febrero 2021

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD TÉCNICA DE AMBATO

FACULTAD DE INGENIERÍA EN SISTEMAS, ELECTRÓNICA E INDUSTRIAL

UNIVERSIDAD TÉCNICA DE AMBATO

FACULTAD DE INGENIERÍA EN SISTEMAS,

CARRERA DE INGENIERÍA EN ELECTRÓNICA Y

Fecha de Entrega: 04 de Diciembre del 2020

Docente: Ing. Edgar Patricio Córdova Córdova

OCTUBRE 2020 - ENERO 2021

El estudio de los microcontroladores abarca un sin números de actividades y temas por

El estudio de comunicación inalámbrica abarca grandes temas y conceptos fundamentales para

Se dice que el lenguaje de Descripción de Hardware (HDL) es un lenguaje de programación

VHDL es un lenguaje de descripción de circuitos electrónicos digitales que pueden ser

La metodología Top-Down de diseño de circuitos electrónicos contiene procesos de capturar

Equipos DE (Digital Electronic) FPGA board NI ......................................................................... 81

Ejercicio propuesto 1 ................................................................................................................... 148

CONVERSOR: Dispositivo electrónico capaz PAL: Clase de dispositivos lógicos

DIAGRAMA DE ESTADOS: Muestra la PRÓXIMO ESTADO: El estado al que irá la

MÁQUINA DE MOORE: Una máquina Moore SEGMENTADO: Denominado también como

SÍNCRONO: Lo que tiene un intervalo de CONTADOR DE CICLOS: Está diseñado

ARDUINO: Plataforma de desarrollo de IDE: Entorno de desarrollo Integrado.

ordenador o computador. instrucciones de entrada.

5. Librerías, Fusibles e Interrupciones.

ARDUINO: es una plataforma de desarrollo BITS: Unidad mínima de información, que

CONVERSOR: Dispositivo electrónico capaz BLUETOOTH: es una especificación

7. Comunicación Inalámbrica Wifi

WIFI: es una tecnología que permite la MCU: Microcontrolador

8. Proceso de programación HDL y VHDL.

HDL: Es un lenguaje de programación mediante componentes que pueden agruparse

10. Convertidor de Código

ESTRUCTURA: Modo de estar organizadas ARQUITECTURA: La arquitectura de

Ilustración 1.- Entrada, Proceso, Salida de un sistema digital [26].

Su representación viene a ser dado mediando algebra booleana [Cando. E, Contreras. S,

Ilustración 3.- Ecuación Sistemas Combinacionales

Sistemas Digitales Secuenciales

Ilustración 4.- Sistema digital síncrono [5].

Ilustración 5.- Sistema digital asíncrono

• Autómata Finito de Mealy

Un autónomo finito cuenta de tres etapas:

1. Sistemas combinacionales de entrada [1].

De la variación de esta estructura se obtienen los Modelos de Mealy y de Moore, a

Ilustración 6.- Etapas autómatas finitos [1].

Ilustración 7.- Funcionamiento Microprocesador [5].

Ilustración 8.- Funcionamiento Microcontrolador [5].

Proceso de programación y ejecución

Ilustración 9.- Proceso de programación y ejecución.

Lenguaje de Programación: Un lenguaje para transmitir a la máquina las órdenes que se le

Sistemas Digitales reconfigurables

Ilustración 10.- Sistemas Digitales reconfigurables

Ilustración 11 Esquema básico de la máquina de Mealy

Ilustración 12 Diagrama de estados Mealy

Ilustración 13 Esquema básico de la máquina de Moore

Ilustración 14 Diagrama de estados Moore

Diseño de Autómatas Finitos

➢ Diagrama de estados: Mediante el diagrama de estados se puede generar:

Tabla de diseño (Sistemas Síncronos)

Aplicaciones de autómatas finitos

Ilustración 15 Detector de Código

Ilustración 16 Detector continuo de cadena 10

Ilustración 17 Detector continuo (Ejemplo)

Ilustración 18 Detector segmentado de cadena 10

Modelo general de un circuito secuencial

Ilustración 20: Circuito secuencial general sincronizado [1]

Ilustración 21: Máquinas de Mealy [28]

Desarrollo de un circuito secuencial