Practicas para Mecatronica Ene-Jun Semestre 4 Modulo 3 - Ver 2022

CENTO DE BACHILLERATO TECNOLÓGICO
INDUSTRIAL Y DE SERVICIOS No. 47
Manual de Prácticas
Para el Cuarto Semestre de Mecatronica
MÓDULO III. Programa Sistemas Mecatrónicos y
Verifica su funcionamiento.
Submódulo 1 - Programa controladores lógicos

programables
Submódulo 2 - Instala y opera componentes de fuerza
y actuadores en sistemas mecatrónico.
Submódulo 3 - Utiliza y programa tarjetas
electrónicas de control.
Periodo Febrero –Junio 2022
Página 1/400
Contenido
PRESENTACIÓN.................................................................................................................................... 6
Justificación de la carrera .................................................................................................................... 7
Modulo III Programa Sistemas Mecatrónicos y Verifica su funcionamiento ............................ 9
Introducción para desarrollo de prácticas de Mecatrónica. ............................................................. 10
Diagrama de Flujo ......................................................................................................................... 14
Nacimiento del Microprocesador y Microcontrolador ................................................................. 16
PROTEUS simulador digital y analógico ................................................................................ 22
Arduino .......................................................................................................................................... 23
Simulador de Arduino ................................................................................................................... 25
Material Empleado: ........................................................................................................................... 27
Equipo Empleado: ............................................................................................................................. 27
Herramienta Empleada ..................................................................................................................... 27
Práctica 1 circuito temporizador 555 PWM y Control en T1 y T2 ........................................... 28
Práctica 2 Circuito Control de Potencia con Transistores. Control de 4 Focos ................... 34
Práctica 3 Circuito Decodificador de Teclado. .......................................................................... 45
Practica 4).- Desarrollo y Simulación Tarjeta Microchip y Proteus ................................................... 53
ANTES ............................................................................................................................................ 54
AHORA ........................................................................................................................................... 56
Practica 5).- Led Intermitente. .......................................................................................................... 68
Practica 6).- Alarma 1 ........................................................................................................................ 73
Practica 7).- Secuencia Básica de tres Leds. ...................................................................................... 78
Practica 8).- Lectura de un Pulsador. ................................................................................................ 83
Practica 9).-Lectura de un sensor de inclinación............................................................................... 89
Practica 10).- Lectura de Entrada Analógica por Potenciómetro...................................................... 95
Practica11).- Coche Fantástico. ....................................................................................................... 101
Practica 12).- Estrella Fugas. ........................................................................................................... 112
Practica 13).- Desarrollar un programa de un contador de eventos. ............................................. 119
Practica 14).- Contador de 0 a 10. ................................................................................................... 127
Practica 15).- Entrada Analógica ..................................................................................................... 133
Practica 16).- Simular de una vela. .................................................................................................. 137
Practica 17).- Indicador de Nivel. .................................................................................................... 142
Página 2/400
Practica 18).-Encender y Apagar una luz con un control analógico. ............................................... 147
Practica 19).- Control de la Iluminación de una lámpara. ............................................................... 152
Practica 20).- Sensor de Luz LDR. .................................................................................................... 157
Practica 21).- Sensor de Temperatura NTC. .................................................................................... 163
Practica 22).- Sensor de Fuerza. ...................................................................................................... 169
Practica 23).- Generador de Notas Musicales. ................................................................................ 174
Practica 24).- Tocar tonos desde el puerto serial............................................................................ 179
Practica 25).- Timbre de llamada. ................................................................................................... 186
Practica 26).- Control de Encendido de un led vía puerto Serie USB. ............................................. 191
Practica 27).-Control de un motor de CD. ....................................................................................... 197
Practica 28).- Control de Motor CD con driver 293D. ..................................................................... 203
Practica 29).- Control de giro de un motor cd CD opción 1. ........................................................... 209
Practica 30).- Control de giro de un motor cd CD opción 2. ........................................................... 214
Practica 31).- Activar un relevador por puerto serie....................................................................... 219
Practica EXAMEN UNIDAD 1).- Diseño de un Circuito Programable .............................................. 224
Práctica 32 Circuito Multiplexor.en PCB .................................................................................. 229
Práctica 33) Diseño de un contador binario con el circuito 7446 en FISICO para PCB. ................ 241
Práctica 34) Diseño de Decodificador 7s con el circuito 7448 en FISICO para PCB....................... 247
Práctica 35) Diseño de un Control para motor de CD y a Pasos con el circuito LM293 en FISICO
para PCB. ........................................................................................................................................ 253
Practica 36).- Desarrollar un Programa que controle el encendido y apagado de 4 relevadores vía
bluetooth......................................................................................................................................... 259
¿Qué vamos a necesitar? ................................................................................................... 260
1- Configurar el módulo Bluetooth ..................................................................................... 260
2- Sketch de Arduino ............................................................................................................... 262
3- Instalar App de Android .................................................................................................. 263
3- Instalar App de Android .................................................................................................. 265
Practica 37).- Desarrollar un Probador de sensores Analógicos y Digitales.................................... 269
Practica 38).- Desarrollar un programa de control de motor de CD, CA, MOT a Pasos y Servo Motor.
Controlar CON POTENCIÓMETRO DIGITAL ..................................................................................... 274
Drivers con Puentes H ............................................................................................................. 276
Señales PWM ........................................................................................................................... 276
Página 3/400
Librerías de programación ...................................................................................................... 277
Conexionado general ............................................................................................................... 278
Características generales de los drivers ............................................................................... 278
Drivers más utilizados en proyectos DIY/DIWO .................................................................. 279
L9110 ...................................................................................................................................... 279
Practica 39).- Armado y prueba de chasis del circuito giratorio de led´s. ...................................... 284
Practica 40).- Desarrollar un Vehículo que se estacione solo evadiendo obstáculos. .................... 294
Practica 41).- Receptor de Control Remoto de TV para prender un ventilador y controlar su
velocidad. ....................................................................................................................................... 298
Control Remoto de TV ............................................................................................................. 300
Librería IR remote para Arduino ............................................................................................. 301
Conexiones entre Arduino y modulo receptor IR................................................................. 301
Encendiendo un led con nuestro control Remoto. .............................................................. 302
Decodificando datos de los controles infrarrojos................................................................. 303
Controlar Pines digitales con control remoto por infrarrojos .............................................. 305
Practica 42).- Emisor de Control Remoto de TV para prender un TV, cambiar canal y variar
volumen con Arduino. ................................................................................................................. 313
EXAMEN UNIDAD 2).- Desarrollo y Simulación Tarjeta Microchip y Proteus ................................. 322
ANTES ........................................................................................................................................ 323
AHORA ....................................................................................................................................... 325
Practica 43).- Desarrollar un programa que controle un módulo de 4 matrices led. .................... 339
Componentes necesarios para el proyecto .......................................................................... 340
Creando patrones en binario .................................................................................................. 348
Practica 44).-Desarrollar un programa de control de display LCD de 4 líneas con I2C y sin control
serial. ............................................................................................................................................... 351
Hardware del Módulo adaptador LCD a I2C ............................................................................... 354
Conexiones entre Arduino y Módulo adaptador LCD a I2C ........................................................ 355
Librería LiquidCrystal_I2C para Arduino ..................................................................................... 355
LiquidCrystal_I2C(lcd_Addr, lcd_cols, lcd_rows) .................................................................... 355
init() ......................................................................................................................................... 355
clear() ...................................................................................................................................... 356
setCursor(col, row) .................................................................................................................. 356
Página 4/400
print() ...................................................................................................................................... 356
scrollDisplayLeft() .................................................................................................................... 356
scrollDisplayRight() .................................................................................................................. 356
backlight();............................................................................................................................... 356
noBacklight(); .......................................................................................................................... 356
createChar (num, datos) ......................................................................................................... 356
Ej 1. Un Hola mundo con Arduino y LCD ..................................................................................... 356
Ej 2. Desplazando el texto en el LCD ........................................................................................... 358
Ej 3. Mostrando datos de sensores o variables en el LCD ........................................................... 359
Ej 4. Agregando nuevos caracteres a nuestro LCD ...................................................................... 361
Practica 45).- Armado y prueba de chasis del circuito giratorio de led´s. ...................................... 367
Practica 46).- Comunicación serie entre arduinos maestro-escavo encender un Led. ....... 379
Practica 47).- Comunicación serie entre arduinos. Hacer un Chat entre dos arduinos. ...... 385
Practica 48).- Comunicación RF entre arduinos maestro esclavo para mover un Móvil. .... 392
Componentes y materiales ..................................................................................................... 393
Emisor de Control Remoto ...................................................................................................... 393
Receptor de Control Remoto .................................................................................................. 394
Código Arduino para el equipo emisor ejemplo ............................................................... 396
Como funciona el módulo joystick ......................................................................................... 397
Código Arduino para el equipo receptor ejemplo ............................................................ 398
Practica 49).- Desarrollar un circuito de una resistencia digital programada por arduino. ............ 402
Practica 50).- Desarrollar un Vehículo controlado por ACELEROMETRO........................................ 410
EXAMEN UNIDAD 3).- Desarrollar un circuito de control para un CUBO DE LEDS 5x5, que muestre
los números del 0 al 9 seleccionados con un control remoto IR. ................................................... 414
Anexo A ....................................................................................................................................... 424
Tipografía de Reporte ................................................................................................................. 424
Anexo B Cronograma de Actividades .......................................................................................... 425
Anexo C Normatividad ................................................................................................................ 426
Anexo Mapa ................................................................................................................................ 428
Bibliografía. ..................................................................................................................................... 429
Página 5/400
PRESENTACIÓN
La Reforma Integral de la Educación Media Superior se orienta a la construcción

de un Sistema Nacional de Bachillerato, con los propósitos de conformar una
identidad propia de este nivel educativo y lograr un perfil común del egresado en
todos los subsistemas y modalidades que lo constituyen, siempre dentro de un
marco de pluralidad interinstitucional.
El perfil común del bachiller se construye a partir de las once competencias
genéricas, que se complementan con las profesionales y las disciplinares básicas,
las cuales favorecen la formación integral del estudiante para su mejor desarrollo
social, laboral y personal, desde la posición de la sustentabilidad y el humanismo.
En esta versión del programa de estudios se confirman, como eje principal de
formación, las estrategias centradas en el aprendizaje y el enfoque de
competencias; con el fin de que se tengan los recursos metodológicos necesarios
para elaborar y aplicar en el aula los módulos y submódulos.
El Gobierno de México y el Banco Interamericano de Desarrollo acordaron
cofinanciar el Programa de Formación de Recursos Humanos basada en
Competencias (PROFORHCOM), Fase II, cuyo objetivo general es contribuir a
mejorar el nivel de competencia de los egresados de educación media superior en
la formación profesional técnica y, por esa vía, sus posibilidades de empleabilidad.
La Coordinación Sectorial de Desarrollo Académico (CoSDAc), de la

Subsecretaría de Educación Media Superior (SEMS), funge como coordinadora
técnica de estos trabajos; su contribución tiene como propósito articular los
esfuerzos interinstitucionales de la DGETA, DGETI, DGECyTM, CECyTE y
DGCFT, para avanzar hacia esquemas cada vez más cercanos a la dinámica
productiva.
Página 6/400
Justificación de la carrera
En el contexto nacional la formación de Técnicos en Mecatrónica es relevante
porque realiza tareas de diagnóstico, instalación, diseño y mantenimiento, a
sistemas Mecatrónicos, detectando anomalías en procesos de producción
automatizados y realizar mantenimientos correctivos y preventivos en procesos
integrales, verificando el funcionamiento de sensores, actuadores, mecanismos y
programas de cómputo, que gobiernan la producción. Preparando a los técnicos
en Mecatrónica a las necesidades que requiere el sector productivo que se
encuentra en constante evolución
Asimismo podrá desarrollar competencias genéricas relacionadas principalmente
con la participación en los procesos de comunicación en distintos contextos, la
integración efectiva a los equipos de trabajo y la intervención consciente, desde su
comunidad en particular, en el país y el mundo en general, todo con apego al
cuidado del medio ambiente.
La carrera de Técnico en Mecatrónica desarrolla en el estudiante las siguientes:
Competencias profesionales:
•Realiza circuitos eléctricos, electrónicos midiendo las variables que integran el
sistema mecatrónico.
•Implementa los elementos mecánicos en un sistema mecatrónico.
•Programa sistemas mecatrónicos y verifica su funcionamiento
•Desarrolla procesos de manufactura
•Mantiene e integra sistemas mecatrónicos
Competencias genéricas:
•Se conoce y valora a sí mismo y aborda problemas y retos teniendo en cuenta los
objetivos que persigue.
•Es sensible al arte y participa en la apreciación e interpretación de sus
expresiones en distintos géneros.
•Elige y practica estilos de vida saludables.
•Escucha, interpreta y emite mensajes pertinentes en distintos contextos mediante
la utilización de medios, códigos y herramientas apropiados.
Página 7/400
•Desarrolla innovaciones y propone soluciones a problemas a partir de métodos
establecidos.
•Sustenta una postura personal sobre temas de interés y relevancia general,
considerando otros puntos de vista de manera crítica y reflexiva.
•Aprende por iniciativa e interés propio a lo largo de la vida.
•Participa y colabora de manera efectiva en equipos diversos.
•Participa con una conciencia cívica y ética en la vida de su comunidad, región,
México y el mundo.
•Mantiene una actitud respetuosa hacia la interculturalidad y la diversidad de
creencias, valores, ideas y prácticas sociales.
•Contribuye al desarrollo sustentable de manera crítica.
Competencia Disciplinares
•Construye e interpreta modelos matemáticos mediante la aplicación de
procedimientos aritméticos, algebraicos, geométricos y variacionales, para la
comprensión y análisis de situaciones reales, hipotéticas o formales.
•Formula y resuelve problemas matemáticos, aplicando diferentes enfoques.
•Explica e interpreta los resultados obtenidos mediante procedimientos
matemáticos y los contrasta con modelos establecidos o situaciones reales.
•Fundamenta opiniones sobre los impactos de la ciencia y la tecnología en su vida
cotidiana, asumiendo consideraciones éticas.
Competencias de Productividad y empleabilidad:
•Realizar actividades para la concreción de objetivos y metas.
•Verificar el cumplimiento de los parámetros de calidad exigido
•Trabajar hasta alcanzar las metas o retos propuestos.
•Diseñar y utilizar indicadores para medir y comprobar los resultados obtenidos
•Buscar y analizar información útil para la solución de problemas de área.
•Observar permanentemente y reportar los cambios presentes en los procesos,
infraestructura e insumos.
•Identificar los comportamientos apropiados para cada situación
•Registrar y revisar información para asegurar que sea correcta
Página 8/400
Modulo III Programa Sistemas Mecatrónicos y Verifica su
funcionamiento
Submódulo 1 - Programa controladores lógicos programables
Submódulo 2 - Instala y opera componentes de fuerza y actuadores

en sistemas mecatrónico.
Submódulo 3 - Utiliza y programa tarjetas electrónicas de control.
Página 9/400
Introducción para desarrollo de prácticas de Mecatrónica.
TECNICAS DE ALAMBRADO
Basándose en el desarrollo de proyectos, prácticas y demás circuitos por realizar
durante la práctica en laboratorio, se tiene que tener en cuenta los siguientes
factores para un buen funcionamiento del mismo.
TIEMPO. Por muy sencillo o complejo sea la práctica, se tiene que tomar un
tiempo para desarrollarla con detenimiento, para evitar lo siguiente:
Errores Comunes
-Errores en construcción: Cortos, falsos contactos, errores en el alambrado.
-Errores en el diseño: Aunque esté alambrado correctamente, se puede tener
fallas en el concepto básico de la práctica.
-Necesidad de adiciones: No se tiene hasta que se prueba la necesidad de añadir
más elementos para el funcionamiento correcto.
Para evitar tener que identificar y arreglar fallas en circuito a probar, o rediseñar se
tiene que tomar uno el tiempo necesario para hacerlo bien desde un principio.
PROCEDIMIENTOS BÁSICOS.
Una de las maneras más básicas para tener un correcto funcionamiento en la
práctica por realizar son:
-Asumir que se van hacer modificaciones: Siempre que se hacen correcciones en
el diseño, arreglando fallas en el alambrado, adicionando circuitería extra,
cambiando los valores de los componentes, o conceptos de reingeniería, se tiene
que escoger el mejor método que permita hacerlo, dejando bastante espacio en el
protoboard para trabajar.
-Identificar todos los pines en CI’s: Aunque se tenga la identificación de los pines
en la hoja de práctica del circuito que se realizara, se tiene que consultar en los
libros de especificaciones del fabricante (data books), para un correcta conexión
tomando en cuenta los voltajes de alimentación, conexiones a tierra, pulsos de
Página 10/400
reloj, resets, enables, entradas y salidas. Cualquier pin no utilizado o compuerta
extra debe ser conectada a tierra o dejarlas desconectadas.
-Aterrizar los CI’s: Esto significa poner un capacitor de cerámica de 0.01 a 0.1mF
de la fuente de +5V a tierra, para evitar que se introduzca ruido de la línea,
ocasionando fallas repentinas.
-Hacer buenas conexiones de la fuente de alimentación y tierra: Un alambrado
débil en la conexión de circuito a circuito no es lo suficiente. Tener un alambrado
más robusto en cuanto a mejor calidad de alambre y distribución en el protoboard
para la fuente y tierra es lo mejor.
-Mantener por separado la circuitería digital de la análoga: La conmutación digital,
especialmente en los buses de microprocesadores puede introducir tipo de ruido y
basura a la circuitería análoga o circuitería de audio.
-No siempre el CI está dañado: Cuando un proyecto no funciona, lo primero a
deducir es que el circuito integrado está dañado, no siempre es esto. En práctica,
la mayoría de los circuitos están a prueba de fallas (mal alambrado, fuente
equivocada), soportando un gran abuso. En lo que si se tiene que tener cuidado
es en la estática. El problema por lo general se encuentra en otra parte.
-No usar ningún tipo de silicón para aislar circuitería: Este tipo de componente es
comúnmente usado, pero no es un aislante. Tendrá fuga de pequeñas corrientes,
que no importan en circuitería lógica, pero si en circuitería análoga de alta
impedancia.
-Construir primero una parte: Cuando se tiene que construir una circuitería muy
compleja o hacer varias idénticas, es recomendable empezar por una parte y
luego sucesivamente las demás, para evitar errores de alambrado.
Página 11/400
Asegurar primero tener el componente antes de la base o el diseño: Se encontrará
el circuito ideal para el proyecto en los manuales de especificaciones del
fabricante, pero puede suceder que este descontinuado, no hay distribuidor para
adquirirlo, o su costo sea muy elevado. Lo correcto es escoger componentes lo
más comerciales posibles.
-Nunca se conecte circuitería sin probar a la computadora: Nunca se debe hacer
esto, cualquier error en el alambrado, la motherboard, y los disk drivers se
quemarán. Hay tarjetas especiales que permiten hacer circuitería en prototipo, el
cual protege la computadora.
-Usar sockets en prototipos: Al terminar un proyecto el cual se quiera pasar a wire
wrapper, PCB, Proteus, etc., donde involucre poner soldadura. Es necesario
poner sockets para los CI’s, antes de colocarlos, así no se dañarán con el calor
aplicado si se soldan directamente.
PROTOBOARD.
Una de las maneras más fáciles de construir una circuitería y de alambrarla, es la
típica tablilla protoboard, pero se tienen ciertas limitaciones:
-Se tiene que distribuir muy bien el espacio para tener una mejor conexión e
identificación de los componentes.
-No se deben de insertar componentes con terminales muy gruesas, pues
dañarían las terminales del protoboard.
-Identificar bien las fuentes y tierras para evitar cortos.
-No es conveniente usar circuitería que involucre altas frecuencias o altas
corrientes.
-Recortar terminales de componentes, lo necesario para no ocasionar cortos, se
introduzca ruido, etc.
Página 12/400
-Tener el área del circuito fuera de cualquier fuente de ruido mecánico, polvo; es lo
mejor para su buen funcionamiento.
-Verificar con un óhmetro las terminales del protoboard para ver si no hay daños.
- Podemos ver un ejemplo en la figura (3) de cómo debe quedar un circuito

alambrado en un protoboard, identifique que los cables van sobre el protoboard
pegados esto es importante pues al colocar cables despegados del protoboard
funcionan como antenas que inducen ruido eléctrico al nuestro circuito y pueden
provocar fallas aleatorias.
Figura (3)
Página 13/400
Diagrama de Flujo
¿Qué son Los Diagramas de Flujo y Para qué se Usan?
Un algoritmo describe una secuencia de pasos escritos para realizar una tarea.
El Diagrama de Flujo es su representación esquemática. Los diagramas de flujo
representan la secuencia lógica o los pasos que tenemos que dar para
realizar una tarea mediante unos símbolos y dentro de ellos se describen los
pasos ha realizar.
Por la tanto son una excelente herramienta para resolver problemas,
comprender el proceso a seguir así como para identificar posibles errores
antes del desarrollo final de la tarea.
Se usan para hacer un programa informático, para analizar lo que tiene que hacer
un robot, en los procesos industriales, etc.
Un diagrama de flujo es útil en todo aquello que se necesite una previa
organización antes de su desarrollo.
En la realización de un programa informático es imprescindible primero realizar el
diagrama de flujo, independientemente del lenguaje de programación que usemos
después. Una vez que tenemos nuestro diagrama de flujo solo tendremos que
conocer las órdenes del lenguaje que realizan esas tareas que se especifican en
el diagrama.
Reglas Básicas Para la Construcción de un Diagrama de Flujo

1. Todos los símbolos han de estar conectados
2. A un símbolo de proceso pueden llegarle varias líneas
3. A un símbolo de decisión pueden llegarle varias líneas, pero sólo saldrán dos
(Si o No, Verdadero o Falso).
4. A un símbolo de inicio nunca le llegan líneas.
5. De un símbolo de fin no parte ninguna línea.
Los símbolos que se usan para realizar los diagramas de flujo son lo siguientes:
Página 14/400
- En el Símbolo de decisión puede tomar los valores de salida SI o NO o también
VERDADERO o FALSO.
- El símbolo de Inicio o Final del Diagrama puedes ser un cuadrado con los bordes
redondeados o una elipse.
- Se pueden utilizar colores para los símbolos. Ejemplo
Página 15/400
Nacimiento del Microprocesador y Microcontrolador
1969 - 1971
1976
MICROCONTROLADORES MICROPROCESADORES
El Microcontrolador vs el Microprocesador en esta entrada se establecerá una

diferencia entre el microprocesador y el microcontrolador, presentando las
ventajas y desventajas entre estos dos dispositivos programables, contrastando
sus principales características al usarlos en la implementación de sistemas
digitales programables y analizando que pasa con cada uno de ellos y: la CPU, las
Memorias RAM y ROM, la Velocidad de Operación, el Tamaño, los Costos, las
Interferencias (ruido), el Tiempo de desarrollo. En cuanto a los microcontroladores,
en realidad, el nombre completo es PIC micro, aunque generalmente se utiliza
como Peripheral Interface Controller (controlador de interfaz periférico).
Página 16/400
Página 17/400
Página 18/400
Página 19/400
AVR= Automatic Voltage Regulator (Regulador automático de voltaje)
Los AVR son una familia de microcontroladores RISC del fabricante estadounidense Atmel,
compañía adquirida por Microchip Technology en 2016.
Microcontrolador vs Microprocesador
Página 20/400
Página 21/400
PROTEUS simulador digital y analógico
Se trata de un completo programa que permite diseñar y simular circuitos
electrónicos de forma práctica y accesible.
A todos aquellos que trabajen en el ámbito de la electrónica les interesará la
aplicación Proteus. Se trata de un completo programa que permite diseñar y
simular circuitos electrónicos de forma práctica y accesible. Proteus está
formado por dos utilidades principales: ARES e ISIS, y por los módulos Electra y
VSM. Si necesitas crear componentes con Proteus e ISIS será una tarea fácil.
Prueba las herramientas ARES e ISIS de Proteus al descargar el programa.
Principales características
 La aplicación ISIS permite generar circuitos reales, y comprobar su
funcionamiento en un PCB (printed circuit board).
 Entorno de diseño gráfico de esquemas electrónicos fácil de utilizar y con
efectivas herramientas.
 Entorno de simulación con la tecnología exclusiva de Proteus de modelación
de sistemas virtuales (VSM).
 Herramienta ARES para el enrutado, ubicación y edición de componentes,
utilizado para la fabricación de placas de circuito impreso.
 Interfaz intuitivo y atractivo estandarizado para todos los componentes
de Proteus.
Proteus cuenta con una gran cantidad de funciones para trabajar con circuitos
electrónicos. Por ejemplo, permite generar pistas de cobre de forma
automática. Además, permite la simulación de PICs casi a tiempo real, de
forma que podemos comprobar si el circuito creado funciona de la forma que
esperábamos.
https://www.enerxia.net/portal/index.php?option=com_content&view=article&id=406:electronica-
proteus-simulador-digital-y-analogico&catid=61&Itemid=142
https://granasesor.wordpress.com/2009/11/26/isis-proteus-intro/
https://sites.google.com/site/proyectosonometrovk1/home/tutorial-proteus
http://profesores.sanvalero.net/~arnadillo/Documentos/Practicas/Analogica/Practica_Simulador%20
electronico/Practicas%20Proteus%20Gari/Proteus%202013_2014.pdf
Página 22/400
Arduino
Arduino es una plataforma de creación de electrónica de código abierto, la
cual está basada en hardware y software libre, flexible y fácil de utilizar para los
creadores y desarrolladores. Esta plataforma permite crear diferentes tipos de
microordenadores de una sola placa a los que la comunidad de creadores puede
darles diferentes tipos de uso.
Para poder entender este concepto, primero vas a tener que entender los
conceptos de hardware libre y el software libre. El hardware libre son los
dispositivos cuyas especificaciones y diagramas son de acceso público, de
manera que cualquiera puede replicarlos. Esto quiere decir que Arduino ofrece las
bases para que cualquier otra persona o empresa pueda crear sus propias
placas, pudiendo ser diferentes entre ellas pero igualmente funcionales al partir de
la misma base.
El software libre son los programas informáticos cuyo código es accesible por
cualquiera para que quien quiera pueda utilizarlo y modificarlo. Arduino ofrece la
plataforma Arduino IDE (Entorno de Desarrollo Integrado), que es un entorno de
programación con el que cualquiera puede crear aplicaciones para las placas
Arduino, de manera que se les puede dar todo tipo de utilidades.
El proyecto nació en 2003, cuando varios estudiantes del Instituto de Diseño
Interactivo de Ivrea, Italia, con el fin de facilitar el acceso y uso de la electrónico y
programación. Lo hicieron para que los estudiantes de electrónica tuviesen una
alternativa más económica a las populares BASIC Stamp, unas placas que por
aquel entonces valían más de cien dólares, y que no todos se podían permitir.
El resultado fue Arduino, una placa con todos los elementos necesarios para
conectar periféricos a las entradas y salidas de un microcontrolador, y que
puede ser programada tanto en Windows como macOS y GNU/Linux. Un proyecto
que promueve la filosofía 'learning by doing', que viene a querer decir que la mejor
manera de aprender es cacharreando.
Es una placa basada en un microcontrolador ATMEL. Los microcontroladores son
circuitos integrados en los que se pueden grabar instrucciones, las cuales las
escribes con el lenguaje de programación que puedes utilizar en el entorno
Página 23/400
Arduino IDE. Estas instrucciones permiten crear programas que interactúan con
los circuitos de la placa.
El microcontrolador de Arduino posee lo que se llama una interfaz de entrada,
que es una conexión en la que podemos conectar en la placa diferentes tipos de
periféricos. La información de estos periféricos que conectes se trasladará al
microcontrolador, el cual se encargará de procesar los datos que le lleguen a
través de ellos.
http://arduino.cl/que-es-arduino/
https://www.xataka.com/basics/que-arduino-como-funciona-que-puedes-hacer-uno
Página 24/400
Simulador de Arduino
¿Qué es simulino?
En esta ocasión les traigo una librería que hará que sus proyectos se vean mucho
mejor, al tiempo que les facilitara el estar colocando los distintos Atmega, cristales,
etc.... para simular los Arduinos, a demás que integra un plus, si un
sensor ultrasonido. Cabe destacar que esta librería no es mía.
Son dos los archivos que necesitaremos:

ARDUINO.LIB
ARDUINO.IDX
Ambos están incluidos en un archivo comprimido en Rar, que podrán obtener

dando clic en el botón de descarga.
INSTALACIÓN
Este paso dependerá de la versión de Isis Proteus que tengas y teniendo los
archivos antes mencionados ya descomprimidos:
Para la versión 7.X:

Tendrás que copiar los archivos que se incluyen en el Rar, en la siguiente
dirección:
Windows de 32 bits:
 C:\Program Files\Labcenter Electronics\Proteus 7 Professional\LIBRARY
Windows de 64 bits:
 C:\Program Files(x86)\Labcenter Electronics\Proteus 7
Professional\LIBRARY
Para la versión 8.X
Tendrás que seguir los siguientes pasos:
 Abrir Isis Proteus
 Crear un nuevo esquemático. (Entrar en la pantalla donde nos deja colocar
componentes para realizar las simulaciones)
Página 25/400
 Dar clic en el menú "Library" y despues en "Library Manager".
 Dar clic en el botón "Create library"
 En la pantalla que se abra, lo único que tienes que hacer es arrastrar los
archivos descargados ahí, en otras palabras copialos a esa carpeta.
 Cierra Proteus, para después volverlo a abrir y listo ya podrás escoger las
placas arduino, como si escogieras cualquier otro componente.
http://universoinformatico-oficial.blogspot.com/2016/07/simulino-v40.html
https://larevanchademufaza.blogspot.com/2016/01/simulino-libreria-para-simular-
arduino.html
Introducción a Microcontroladores
¿Qué es un Microprocesador?
Un microcontrolador es un circuito integrado o “chip” (es decir, un dispositivo
electrónico que integra en un solo encapsulado un gran número de componentes)
que tiene la característica de ser programable. Es decir, que es capaz de ejecutar
de forma autónoma una serie de instrucciones previamente definidas por nosotros.
En el diagrama anterior, representativo de un sistema electrónico, el
microcontrolador sería el componente principal de la circuitería de procesamiento
y control.
Por definición, un microcontrolador (también llamado comúnmente “micro”) ha de
incluir en su interior tres elementos básicos:
CPU, UMEM y ALU
CPU (Unidad Central de Proceso): es la parte encargada de ejecutar cada
instrucción y de controlar que dicha ejecución se realice correctamente.
Normalmente, estas instrucciones hacen uso de datos disponibles previamente
(los “datos de entrada”), y generan como resultado otros datos diferentes (los
“datos de salida”), que podrán ser utilizados (o no).
Página 26/400
Equipo Empleado:
Material Empleado: 1 Protoboard
25 Resistencias de 470 ohm, 1k, 1 Fuente de 12VCD
4.7k, 10k, 220ohm de c/u 1 Fuente 5VCD
125 Led´s de colores 1 Punta lógica
1 Capacitores Electrolíticos 10, 1 Multímetro
100,1000 y 2200 micro fd 1 Batería de 12VCD
1 Capacitores Cerámicos de 1 Osciloscopio.
.0.1, 0.2, 0.68, 0.01, 0.02 y 0.068 1 Computadora con SW de
micro fd simulación electrónica.
2m Cable telefónico o UTP
2 Interruptores sencillos
1 Sensor de movimiento Herramienta Empleada
2 Sensor de Ultrasonico 1 Pinza de Corte
6 Sensor Óptico IR y FotoR 1 Pinza de Punta
1 Rueda Encoder 1 Desarmador Plano
1 Probador y control de sensores 1 Desarmador de Cruz
Analógico Digital. 1 Cúter
4 Diodos 4001 1 Cautín
2 CI 7805 y CI 7812 1 Juego de Caimanes
2 CI 7905 y CI 7912
5 Pulsadores NC
5 Pulsadores NA
1 Modulo Salida Relevador
1 Modulo Salida Opto-copler
2 Motor de CD 9v
1 Motor de CA 120 v
1 SCR ó TRIAC o Drimmer
1 DIAC
1 Microcontrolador
1 Tarjeta programable con PIC
1 Mapa de código de colores de
resistencias.
1 Transformador 120v a 12 v
20 Conectores Varios.
4 Micro SW de 8 pines.
1 Motor Servo
1 Motor a Pasos
1 Puente H
1 Cristal OSC 4MHz
1 CI LM317
4 Display 7s
1 Mod LCD 4 lineas
1 Mod de 4 Matrices de leds
Página 27/400
Práctica 1 circuito temporizador 555 PWM y Control en T1 y T2
OBJETIVOS:
Uso de Driver 555 temporizador PWM COMPLETO.
Información general:
En un circuito integrado o chip se montan en un mismo componente varios

transistores, diodos, condensadores o resistencias, es decir, todos los elementos
necesarios para que un circuito realice la función para la que ha sido diseñado. En
este caso, con el CI 555, lo que tenemos es un circuito temporizador, astable (se
activa y desactiva cada cierto tiempo, a una frecuencia determinada para T1 y T2).
Recordando la unidad anterior veamos nuevamente el CI 555.

En el caso del 555 sería:
Página 28/400
Donde:
• GND (1): es el polo negativo de alimentación o tierra (GROUND).
• Disparo (2): donde se activa el circuito, el que da inicio al temporizado.
• Salida (3): donde conectaremos el componente de salida, en nuestro caso un
diodo LED.
• Reinicio (4): para volver a iniciar el circuito, si no la queremos usar debemos
conectarla al polo positivo.
• Control de voltaje (5): no lo vamos a conectar, pero serviría para funciones más
avanzadas del circuito.
• Umbral (6): entrada a un comparador que establece el tiempo de temporizado.
• Descarga (7): donde se descarga un condensador que establece el tiempo de
temporizado.
• Vcc (8): donde se conecta el voltaje de alimentación, el polo positivo (+), en este
caso 9 V.
Diagrama
MONTAJE CIRCUITO ASTABLE MODIFICADO PARA CONTROLAR T1 Y T2
1. Partiendo del circuito anterior haz las modificaciones necesarias para llegar a lo
slicitado:
Página 29/400
PROCEDIMIENTO:
Actividad 1).-. Analice el siguiente circuito de la figura (2) ármelo como se indica
Fig. (2)
Armar la simulación siguiente:
Página 30/400
Página 31/400
Actividad 2).-Con base a su investigación de los CI ASTABLES explicar cómo
funciona.
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
Actividad 3) Armar el circuito físicamente, mostrarlo y describir el
funcionamiento que soluciona la problemática.
R:
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
Actividad 4).- Anotar conclusiones y recomendaciones.
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
R:
_________________________________________________________________
_________________________________________________________________
Página 32/400
Actividad 5).-Mostrar el funcionamiento de su trabajo al profesor, si tienen dudas
preguntar, pues le deberá quedar completamente claro el funcionamiento de su
circuito.
Nombre del Alumno: _______________________________________________

Grado: _____________________ Grupo ___________________________
Nombre del Profesor: _______________________________________________
Firma del Profesor: ___________________ Fecha: ______________________
Actividad 6).-Hacer su reporte a computadora siguiendo la tipografía indicada en el

Anexo A de este manual, tomando los datos de este borrador. El reporte será
UNO por equipo.
Página 33/400
Práctica 2 Circuito Control de Potencia con Transistores. Control de 4 Focos
OBJETIVOS:
Uso de Driver Control de Potencia con Transistores.
Qué es un Transistor
El transistor es un dispositivo electrónico semiconductor que cumple funciones de
amplificador, oscilador, conmutador o rectificador. El término "transistor"
("resistencia de transferencia"). Actualmente se les encuentra prácticamente en
todos los enseres domésticos de uso diario: radios, televisores, grabadoras,
reproductores de audio y vídeo, hornos de microondas, lavadoras, reproductores
mp3, celulares, etc.
El transistor consta de un sustrato (usualmente silicio) y tres partes dopadas

artificialmente (contaminadas con materiales específicos en cantidades
específicos) que forman dos uniones bipolares, el emisor que emite portadores, el
colector que los recibe o recolecta y la tercera, que está intercalada entre las dos
primeras, modula el paso de dichos portadores (base). El transistor es un
dispositivo controlado por corriente y del que se obtiene corriente amplificada.
Tipos de Transistor
Transistor de contacto puntual
Primer transistor, consta de una base de germanio semiconductor, sobre la que se

apoyan, muy juntas, dos puntas metálicas que constituyen el emisor y el colector.
La corriente de base es capaz de modular la resistencia que se "ve" en el colector.
Es difícil de fabricar (las puntas se ajustaban a mano), frágil (un golpe podía
desplazar las puntas) y ruidoso, en la actualidad ha desaparecido.
Página 34/400
Transistor de unión bipolar
El transistor de unión, se fabrica básicamente sobre un monocristal de Germanio o
Silicio, que tienen cualidades de semiconductores, estado intermedio entre
conductores como los metales y los aislantes como el diamante. Sobre el sustrato
de cristal, se contaminan en forma muy controlada tres zonas, dos de las cuales
son del mismo tipo, NPN o PNP, quedando formadas dos uniones NP.
La zona N con donantes de electrones (cargas negativas) y la zona P de

aceptadores (cargas positivas). Normalmente se utilizan como elementos
aceptadores P al Indio (In), Aluminio (Al) o Galio (Ga) y donantes N al Arsénico
(As) o Fósforo (P).
La configuración de uniones PN, dan como resultado transistores PNP o NPN,

donde la letra intermedia siempre corresponde a la característica de la base, y las
otras dos al emisor y al colector que, si bien son del mismo tipo y de signo
contrario a la base, tienen diferente contaminación (impurezas adicionadas
intencionalmente) entre ellas (por lo general, el emisor está mucho más
contaminado que el colector).
Transistor de efecto de campo
El transistor de efecto campo es una familia de transistores que se basan en el

campo eléctrico para controlar la conductividad de un "canal" en un material
semiconductor. Los FET pueden plantearse como resistencias controladas por
diferencia de potencial.
La mayoría de los FET están hechos usando las técnicas de procesado de

semiconductores habituales, empleando la oblea monocristalina semiconductora
como la región activa o canal.
Página 35/400
Los transistores de efecto de campo más conocidos son los JFET, MOSFET y
MISFET.
Página 36/400
Fototransistor
Sensible a la luz, normalmente a los infrarrojos. La luz incide sobre la región de
base, generando portadores en ella. Esta carga de base lleva el transistor al
estado de conducción. El fototransistor es más sensible que el fotodiodo por el
efecto de ganancia propio del transistor.
Un fototransistor es igual a un transistor común, con la diferencia que el primero

puede trabajar de 2 formas:
1.- Como transistor normal con la corriente de base Ib (modo común).
2.- Como fototransistor, cuando la luz que incide en este elemento hace las veces
de corriente de base. Ip (modo de iluminación).
Se han utilizado en lectores de cinta y tarjetas perforadas, lápices ópticos, etc.

Para comunicaciones con fibra óptica se prefiere usar detectores con fotodiodos p-
i-n. También se pueden utilizar en la detección de objetos cercanos cuando
forman parte de un sensor de proximidad.
Se utilizan ampliamente encapsulados conjuntamente con un LED, formando

interruptores ópticos (opto-switch), que detectan la interrupción del haz de luz por
un objeto. Existen en dos versiones: de transmisión y de reflexión.
Página 37/400
Disipadores de calor
Un disipador es un componente metálico generalmente de aluminio que se utilizan

para evitar que los transistores bipolares se calienten y se dañen.
Por ello una manera de aumentar la potencia de un transistor es deshacerse del
calor interno del encapsulado.
Transistor de potencia
Son similares a los transistores comunes, con la diferencia que soportan altas
tensiones e intensidades que soportan, pero debido a ello también tienen que
disipar altas potencias y su recalentamiento es prolongado; para evitar el
sobrerecalentamiento se usa los disipadores.
Tipos de transistores de potencia:
- Bipolar.
- Unipolar o Transistor de Efecto de Campo.
- IGBT (Transistor bipolar de puerta aislada).
Página 38/400
Simbología de un Transistor
Página 39/400
Drivers con transistores.
Página 40/400
Diagrama
MONTAJE CIRCUITO
requerido.
PROCEDIMIENTO:
Actividad 1).-. Analice el siguiente sistema visualizador de números de la figura (2)
ármelo como se indica Fig. (2)
Página 41/400
Página 42/400
Actividad 2).-Con base a su investigación de los CI Control de Potencia con
transstores, explicar cómo funciona.
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
R:
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
R:
_________________________________________________________________
_________________________________________________________________
Página 43/400
Actividad 5).-
Mostrar el funcionamiento de su trabajo al profesor, si tienen dudas preguntar,
pues le deberá quedar completamente claro el funcionamiento de su circuito.
Grado: _____________________ Grupo ___________________________
Actividad 6).-
Hacer su reporte a computadora siguiendo la tipografía indicada en el Anexo A de
este manual, tomando los datos de este borrador. El reporte será UNO por equipo.
Página 44/400
Práctica 3 Circuito Decodificador de Teclado.
OBJETIVOS:
Uso de circuito integrado 74c922 decodificador de teclado 4x4.
¿Qué es un Circuito Codificador y que es un Circuito Decodificador?
Codificadores:
Un codificador es un circuito combinacional con “n” entradas y “m” salidas, cuya
misión es presentar en la salida el código binario correspondiente a la entrada
activada.
Existen dos tipos fundamentales de codificadores: codificadores sin prioridad y

codificadores con prioridad.
En el caso de codificadores sin prioridad, puede darse el caso de salidas cuya
entrada no pueda ser conocida: por ejemplo, la salida 0 podría indicar que no hay
ninguna entrada activada o que se ha activado la entrada número 0. Además,
ciertas entradas pueden hacer que en la salida se presente la suma lógica de
dichas entradas, ocasionando mayor confusión. Por ello, este tipo de codificadores
es usado únicamente cuando el rango de datos de entrada está correctamente
acotado y su funcionamiento garantizado.
Dirección local de lugar.

Para evitar los problemas anteriormente comentados, se diseñan los codificadores
con prioridad. En estos sistemas, cuando existe más de una señal activa, la salida
codifica la de mayor prioridad (generalmente correspondiente al valor decimal más
alto). Adicionalmente, se codifican dos salidas más: una indica que ninguna
entrada está activa, y la otra que alguna entrada está activa.
Página 45/400
Esta medida permite discernir entre los supuestos de que el circuito estuviera
deshabilitado por la no activación de la señal de capacitación, que el circuito no
tuviera ninguna entrada activa, o que la entrada número 0 estuviera activada.
También entendemos como codificador (códec), un esquema que regula una serie
de transformaciones sobre una señal o información. Estos pueden transformar una
señal a una forma codificada usada para la transmisión o cifrado o bien obtener la
señal adecuada para la visualización o edición (no necesariamente la forma
original) a partir de la forma codificada.
En este caso, los codificadores son utilizados en archivos multimedia para

comprimir audio, imagen o vídeo, ya que la forma original de este tipo de archivos
es demasiado grande para ser procesada y transmitida por los sistema de
comunicación disponibles actualmente. Se utilizan también en la compresión de
datos para obtener un tamaño de archivo menor.
Según esta nueva definición, podemos dividir los codificadores en códecs sin
pérdidas y códecs con pérdidas, según si la información que se recupera coincide
exactamente con la original o es una aproximación.
Decodificadores:
Tienen como función detectar la presencia de una determinada combinación de
bits en sus entradas y señalar la presencia de este código mediante un cierto nivel
de salida.
Un decodificador posee N líneas de entrada para gestionar N bits y en una de las
2N líneas de salida indica la presencia de una o mas combinaciones de n bits.
Para cualquier código dado en las entradas solo se activa una de las N posibles
salidas.
Página 46/400
TIPOS DE DECODIFICADORES
1. Decodificadores binarios básicos. Cuando se quiere determinar cuando por

ejemplo aparece 1001 en las entradas de un circuito digital.
Todas las entradas de la puerta AND están a nivel ALTO ya que dicha puerta
produce una salida a nivel ALTO.
2. El decodificador de 4 bits ó decodificador 1 de 16. Se utiliza para poder

decodificar todas las combinaciones de 4 bits. Para cualquier código dado en las
entradas solo se activa una de las posibles dieciséis salidas. Si requerimos una
salida a nivel bajo, el decodificador de puede implementar con puertas NAND e
inversores, uno por cada salida.
A continuación se muestra la tabla de verdad de un decodificador 1 de 16 con
salidas activas a nivel alto.
3. El decodificador BCD a decimal. Convierte cada código BCD en uno de los diez
posibles dígitos decimales. El método de implementación es el mismo que para un
decodificador 4 a 16, pero con la diferencia de que las salidas son solo 10.
Obtendremos salidas activas a nivel ALTO y BAJO implementando las funciones
con puertas AND y NAND respectivamente.
4. Decodificadores BCD a 7 segmentos Es un circuito combinacional que permite

un código BCD en sus entradas y en sus salidas activa un display de 7 segmentos
para indicar un dígito decimal. El display está formado por un conjunto de 7 leds
conectados en un punto común en su salida, bien en ánodo comun ó ánodo
común.
Página 47/400
Función del circuito integrado 74c922 Decodificador
Con este dispositivo se puede controlar fácilmente y sin necesidad de ninguna
librería un teclado 4X4, ampliable fácilmente a 2 teclados 4X4.
Básicamente el circuito consta de ocho entradas (x1 a x4, y1 a y4), donde

conectaremos las cuatro filas y columnas del teclado. La salida en función de la
tecla pulsada la tendremos en formato binario en las patillas A, B, C y D. Si miráis
el esquema de bloques del componente, veréis que estas salidas van a través de
unas básculas tipo D que hacen de memoria, con lo que el valor de la tecla
pulsada se mantiene hasta que se pulsa otra y sobrescribe el antiguo valor.
Además dispone de una salida (DA) que se pone a nivel alto cada vez que se
pulsa una tecla (ideal para el empleo de interrupciones).
Diagrama
MONTAJE CIRCUITO
requerido.
Página 48/400
PROCEDIMIENTO:
Actividad 1).-. Analice el siguiente sistema visualizador de números de la figura (2)
ármelo como se indica Fig. (2)
Página 49/400
Página 50/400
Actividad 2).-Con base a su investigación de los CI Decodificadores, explicar cómo
funciona.
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
R:
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
R:
_________________________________________________________________
_________________________________________________________________
Página 51/400
Actividad 5).-
Grado: _____________________ Grupo ___________________________
Actividad 6).-
Página 52/400
Practica 4).- Desarrollo y Simulación Tarjeta Microchip y Proteus
Objetivo: Desarrollar una placa entrenadora, probar con un simulador, y
posteriormente impemente su circuito físicamente, Hacer sus anotaciones
correspondientes.
NOTA: Ver Archivo anexo de Power Point de MicroControladores.
Tarea 1: Investigar sobre Programa de Simulación Proteus y Pic’s

Complemento Apuntes 1 Métodos de Instalación de Software
Tiempo para desarrollo de Práctica
Lectura de Práctica y Análisis ----10 min

Programación: ----10 min
Armado de Circuito en Simución ----10 min
Tiempo de Detección y Corrección de Errores ----15 min
Entrega para firmar ------5 min
Tiempo total min 50 min máximo 60 min
Actividad 1 Verificar contar con su simulador ya instalado.

Actividad 2 Analizar el Diagrama de Flujo de la figura
Actividad 3 Ver el código ejemplo mostrado aquí y leerlo.
Actividad 4 Cargar el programa *.HEX ejemplo mostrado (PIDALO AL PROFESOR
Actividad 5 Compilar el programa verificar que no tenga errores
Actividad 6 Armar el circuito de la figura en Proteus
Actividad 7 Descarga el Programa a su SIMULADOR correspondiente.
Actividad 8 Verifique el buen funcionamiento de su programa y circuito, de no ser
asi modifique hasta que dé el correcto.
Página 53/400
ANTES
Prgrama Programa para programar el Pic
Prgramador
Programa para bajar el programa al el Pic
Página 54/400
Diseño de PCB para pic
Página 55/400
AHORA
Programar y bajar al pic
Simular pic
Armar circuito
Página 56/400
Desarrollo: 1.PRG1-Prender 4 Leds del puerto B del pic 16f84. –PRG 2 Led que
parpadea. – PRG 3 Condicional IF. – PRG 4 Hacer el encendido de 4 rutinas diferentes
de leds. PRG 5 – Contador Binario
Se trata de realizar un ejercicio básico que consiste en encender 4 leds que
conectamos en el puerto B del pic 16f84 que se configura como salida.
Diagrama de Flujo y Esquema Eléctrico 1.0
INICIO
EJECUCION DE PROCESOS
DEL PRGRAMA
DECLARANDO PUERTO Y
VARIABLES
NO
ASIGNANADO VALOR A SI
SALIDAS Y ENTRADAS DE CONDICIONAL
LOS PUERTOS
Esquema de conexionado con PIC aplica para los 5 programas.
Página 57/400
Diseñar el Circuito PCB del pic 16f84 y Grabe el PROGRAMA PIC-5.HEX
Página 58/400
Página 59/400
PROGRAMA 1
'****************************************************************
'* Name : UNTITLED.BAS *
'* Author : [select VIEW...EDITOR OPTIONS] *
'* Notice : Copyright (c) 2008 [select VIEW...EDITOR OPTIONS] *
'* : All Rights Reserved *
'* Date : 05/11/2008 *
'* Version : 1.0 *
'* Notes : *
'* : *
'****************************************************************
'
' para el 16f84 no se pone nada
' para pic 16f628A
' deshabilitar los convertidores analogico digital
' cmcon = 7
high 0 'ponea a 1 el bit 0 de RB
end
Página 60/400
PROGRAMA 2
'****************************************************************
'* Date : 05/11/2008 *
'* Version : 1.0 *
'* Notes : *
'* : *
'****************************************************************
'
' para pic 16f628A
'cmcon = 7
LED VAR PORTB.0 'DEFINE RB0 AS LED
LED1 VAR PORTB.1
LED2 VAR PORTB.2
LED3 VAR PORTB.3
'
'START OF MAIN PROGAM
'
TRISB=0 ' SET PORTB PINS AS OUTPUTS
AGAIN: ' ETIQUETA
LED = 1 ' PONE LED A 1
LED1 = 0
LED2 = 0
LED3 = 0
PAUSE 1000 ' ESPERA UN SEGUNDO PRENDIDO
LED = 0 ' PONE LED A CERO
PAUSE 1000 ' ESPERA UN SEGUNDO
GOTO AGAIN ' SALTA A ETIQUETA AGAIN
END
' trisb=0 'poner puerto b como salida

' repite:
' portb=1 'encender el led conectado a puerto B0
' pause 1000 ' pausa por 1 segundo 1000ms
' portb=0 ' pone a cero el led del puerto B0
' goto repite ' repite l ciclo infinito
'end
Página 61/400
PROGRAMA 3
'****************************************************************
'* Date : 05/11/2008 *
'* Version : 1.0 *
'* Notes : *
'* : *
'****************************************************************
'
' para pic 16f628A
'cmcon = 7
TRISA=%11111111
TRISB=0
repite:
IF PORTA.0=1 THEN
HIGH 0
ELSE
LOW 0
ENDIF
IF PORTA.1=1 THEN
HIGH 1
ELSE
LOW 1
ENDIF
IF PORTA.2=1 THEN
HIGH 2
ELSE
LOW 2
ENDIF
IF PORTA.3=1 THEN
HIGH 3
ELSE
LOW 3
ENDIF
goto repite
END
Página 62/400
PROGRAMA 4
'****************************************************************
'* Date : 05/11/2008 *
'* Version : 1.0 *
'* Notes : *
'* : *
'****************************************************************
'
' para pic 16f628A
'cmcon = 7
TRISA=%11111111
TRISB=0
repite:
IF PORTA.0=1 THEN
'pause 10
HIGH 0
high 2
high 4
HIGH 6
ELSE
'LOW 0
'LOW 2
'LOW 4
ENDIF
IF PORTA.1=1 THEN
HIGH 1
HIGH 3
HIGH 5
HIGH 7
ELSE
'LOW 1
'LOW 3
'LOW 5
ENDIF
IF PORTA.2=1 THEN
Página 63/400
HIGH 4
ELSE
'LOW 4
ENDIF
IF PORTA.3=1 THEN
HIGH 0
HIGH 1
HIGH 2
HIGH 3
HIGH 4
HIGH 5
HIGH 6
HIGH 7
ELSE
'LOW 0
'LOW 1
'LOW 2
'LOW 3
'LOW 4
'LOW 5
ENDIF
pause 50
LOW 0
LOW 1
LOW 2
LOW 3
LOW 4
LOW 5
LOW 6
LOW 7
goto repite
END
Página 64/400
PROGRAMA 5
'****************************************************************
'* Date : 05/11/2008 *
'* Version : 1.0 *
'* Notes : *
'* : *
'****************************************************************
' CONTADOR BINARIO DE 8 BIT´S
' para pic 16f628A
' CONTADOR DIGITAL
'cmcon = 7
' TRISA=%11111111
' TRISB=0
DEFINE OSC 12
X VAR BYTE
CNT VAR BYTE
TRISB=0
CNT=%00000000
REPITE:
FOR X=1 TO 255
PORTB=CNT
PAUSE 550
CNT =CNT +1
NEXT X
GOTO REPITE
END
Página 65/400
Actividad 9 Descargar su archivo *.hex correspondiente a la práctica y Mostrar el
funcionamiento de su trabajo al profesor, si tienen dudas preguntar, pues le
deberá quedar completamente claro el funcionamiento de su circuito.
DESCRIBA FUNCIONAMIENTO DE SU PRÁCTICA:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 66/400
Nombre del Alumno: ________________________________________________
Grado: _____________________ Grupo ____________________________
Nombre del Profesor: ________________________________________________
Actividad 10

La Actividad 10 será su calificación correspondiente al punto Proyecto Y/O

Investigación según su tabla de evaluación.
Página 67/400
Practica 5).- Led Intermitente.
Objetivo: Realizar un ejercicio básico que consiste en encender y apagar un led
que conectamos en el PIN 13 de Arduino que lo configuramos como salida. El
tiempo de encendido y apagado es de 1 segundo.
Tarea 1: Investigar sobre Programa de Instalación Arduino

Complemento Apuntes 1 Métodos de Instalación de Sofware Arduino

Armado de Circuito ----15 min
Actividad 1 Verificar contar con todo su material.

Actividad 4 Desarrollar el programa tomando como ejemplo el mostrado aquí
Actividad 5 Compilar el programa verificar que no tenga errores y de ser asi
componer el programa hasta que funcione correctamente.
Actividad 6 Armar el circuito de la figura
Actividad 7 Descarga el Programa a su Tarjeta Entrenadora correspondiente.
asi modifique hasta que dé el resultado indicado en el objetivo de la práctica.
Página 68/400
Desarrollo: 3.Led Intermitente
Se trata de realizar un ejercicio básico que consiste en encender y apagar un led
que conectamos en el PIN 13 de Arduino que lo configuramos como salida. El
tiempo de encendido y apagado es de 1 segundo.
Organigrama y esquema de conexionado con la tarjeta Arduino

Obsérvese que se ha colocado el diodo led sin resistencia en serie dado que el
PIN13 de Arduino ya lleva incorporada una resistencia interior, en el caso de
colocar el diodo LED en otra salida deberíamos colocar una resistencia de al entre
220 y 500 ohmios dependiendo del consumo de corriente del diodo
Página 69/400
Programa
/*
* Intermitente
*
* Ejemplo básico con Arduino. Encendido y apagado de un led
* con una cadencia de 1 sg. usando el PIN 13 como salida
* no es necesario usar una resistencia para el led
* la salida 13 de Arduino la lleva incorporada.
*
* http://www.arduino.cc/en/Tutorial/Blink
*/
int ledPin = 13; // Definición de la salida en el PIN 13
void setup() //Configuración
{
pinMode(ledPin, OUTPUT); // designa la salida digital al PIN 13
}
void loop() // bucle de funcionamiento
{
digitalWrite(ledPin, HIGH); // activa el LED
delay(1000); // espera 1 seg. (tiempo encendido)
digitalWrite(ledPin, LOW); // desactiva el LED
delay(1000); // espera 1 seg. (tiempo apagado)
}
Página 70/400
Actividad 9 (Puntos de Trabajo en clase, deberá estar firmado por su profesor)
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 71/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 72/400
Practica 6).- Alarma 1
Objetivo: Desarrollar un programa que cuando se pulsa el pulsador (entrada5 a
“0”) se enciende y se apaga de forma intermitente la salida 13.
Tarea 2: Investigar sobre Programación en arduino

Complemento Apuntes 2 Sobre Entradas Analógicas y Digitales de Arduino.


Página 73/400
Desarrollo: 2. Alarma-1
Cuando se pulsa el pulsador (entrada5 a “0”) se enciende y se apaga de forma
intermitente la salida 13
Funcionamiento:
Cuando la E5 = 1 Entonces S13 = 0
Cuando la E5 = 0 Entonces S13 = 0-1 (Intermitente 200,200 ms)
Página 74/400
Programa.
int ledPin= 13; // choose the pin for the LED
int inPin= 5; // choose the input pin (for a pushbutton)
int val= 0; // variable for reading the pin status
void setup() {
pinMode(ledPin, OUTPUT); // declare LED as output
pinMode(inPin, INPUT); // declare pushbutton as input
}
void loop(){
val= digitalRead(inPin); // lee valor de entrada
if(val== HIGH) { // chequea si el valor leído es “1” (botón presionado)
digitalWrite(ledPin, LOW); // pone el LED en OFF
} else{
digitalWrite(ledPin, LOW); // parpadea el LED
delay(200);
digitalWrite(ledPin, HIGH);
delay(200);
}
}
Página 75/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 76/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 77/400
Practica 7).- Secuencia Básica de tres Leds.
Objetivo: Desarrollar un program para arduino que deba de encender y apagar 3
LEDs colocados en las salidas 6, 7 y 8 (PIN6, PIN7 y PIN8) con una cadencia de
200 ms. Las variables asignadas a cada led son ledPin1, ledPin2 y ledPin3.
Tarea 3: Investigar sobre ¿Qué es un secuenciador digital?

Complemento Apuntes 3 Sobre Registro de Corrimiento.


Página 78/400
Desarrollo: 3. Secuencia Básica de 3 LEDs
Se trata de encender y apagar 3 LEDs colocados en las salidas 6, 7 y 8 (PIN6,
PIN7 y PIN8) con una cadencia de 200 ms. Las variables asignadas a cada led
son ledPin1, ledPin2 y ledPin3
Programa
// Encendido y apagado de 3 LEDs
int ledPin1 = 6; // Define las salidas de los LED´s
int ledPin2 = 7;
int ledPin3 = 8;
void setup() { // Configura las SALIDAS
pinMode(ledPin1, OUTPUT); // declarar LEDs como SALIDAS
pinMode(ledPin2, OUTPUT);
digitalWrite(ledPin1, LOW); // Apaga los LEDs
digitalWrite(ledPin2, LOW);
}
void loop(){ //Bucle de Funcionamiento
Página 79/400
digitalWrite(ledPin1, HIGH); // Apaga y enciende los leds cada 200 ms
delay(200);
digitalWrite(ledPin2, HIGH);
delay(200);
digitalWrite(ledPin3, HIGH);
delay(200);
}
Página 80/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 81/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 82/400
Practica 8).- Lectura de un Pulsador.
Objetivo: Desarrollar un programa que identifique entradas Rabajo(pull-down) y
Rarriba (pull-up)
Tarea 4: Investigar sobre Pulsadores tipos y formas

Complemento Apuntes 4 Sobre Entradas sin Rebote de pulsos electricos


Página 83/400
Desarrollo: 4. Lectura de un pulsador
Descripción del ejercicio
El pulsador es un componente que conecta dos puntos de un circuito cuando es
presionado.
Para generar una señal de tensión con el pulsador, se necesita un divisor de

tensión.
Ejemplo:
La resistencia Rabajo(pull-down) en el primer circuito fuerza a Vout, llegando a

nivel CERO, hasta que se acciona el pulsador. Este circuito entrega una tensión
alta, cuando se presiona el pulsador. Un valor para la resistencia de 10 k es
adecuada.
En el segundo circuito, la resistencia Rarriba (pull-up) fuerza a nivel ALTO a Vout,
mientras no se actúe sobre el pulsador. Al presionar el pulsador, se conecta Vout
directamente con 0 V. Es decir, este circuito entrega un nivel BAJO cuando se
presiona el pulsador.
Elementos necesarios:
Un resistencia de 1K Ohmios.
Un pulsador.
Un diodo LED
Cables para realizar las conexiones.
Página 84/400
Se utiliza una resistencia pull-dowm, junto con un pulsador, para conectarla a un
pin de entrada digital, y de esta forma, poder saber cuando el pulsador es
presionado. Si el pulsador está presionado, el valor del pin 10 será de 0 voltios
(LOW) en caso contrario será de + 5 voltios (HIGH).
En una placa protoboard debe haber una resistencia de 10K conectada entre el
pin de entrada y tierra como se ve el esquema y foto inferiores.
Esquema
Página 85/400
Programa
/* Pulsador
* --------
*
* Detecta si el botón ha sido presionado o no
* y enciende el LED en consecuencia.
*
* Massimo Banzi
*
*/
int ledPin = 13; // PIN del LED
int inPin = 10; // PIN del pulsador
int value = 0; // Valor del pulsador
void setup() {
pinMode(ledPin, OUTPUT); // Inicializa el pin 13 como salida digital
pinMode(inPin, INPUT); // Inicializa el pin 10 como entrada digital
}
void loop() {
value = digitalRead(inPin); // Lee el valor de la entrada digital
digitalWrite(ledPin, value);
}
Página 86/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 87/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 88/400
Practica 9).-Lectura de un sensor de inclinación.
Objetivo: Desarrollar un programa que lea el sensor de inclinación.
Tarea 5: Investigar sobre Sensores de inclinación

Complemento Apuntes 5 Sobre Entradas Analógicas y Digitales


Página 89/400
Desarrollo: 5. Lectura de un sensor de inclinación
El sensor de inclinación es un componente que puede detectar la inclinación de un
objeto. Sin embargo, no deja de ser un pulsador activado por un mecanismo físico
diferente. Este tipo de sensor es la versión ecológica de un interruptor de
mercurio. Contiene una bola metálica en su interior que conmuta los dos pines del
dispositivo de encendido a apagado, y viceversa, si el sensor llega a un cierto
ángulo.
El código de ejemplo es el mismo que se empleó para el ejemplo del pulsador,

pero sustituyendo este último por el sensor de inclinación. Usamos una resistencia
de pull-up (de esta manera usamos la "activación a nivel bajo" para activar los
pines) y conectamos el sensor al pin de entrada digital que leeremos cuando lo
necesitemos.
Se ha utilizado una resistencia de 1K para montar la resistencia de pull-up y el
sensor. Hemos elegido un sensor de inclinación de Assemtech.
Una resistencia de 10K Ohmios.
Un sensor de inclinación Assemtech.
Un diodo LED.
Página 90/400
Programa
/* Sensor de Inclinación
* -----------
* Detecta si el sensor ha sido inclinado o no y
* enciende la luz en consecuencia. Ten en cuenta que
* al utilizar la "activación a nivel bajo" (mediante
* una resistencia de pulls-up) la entrada se encuentra
* a nivel bajo cuando el sensor se activa.
*
* (cleft) David Cuartielles for DojoCorp and K3
* @author: D. Cuartielles
*/
int ledPin = 13; // PIN del LED
int inPin = 7; // PIN del pulsador
int value = 0; // Valor del pulsador
void setup() {
pinMode(ledPin, OUTPUT); // Inicializa el pin 13 como salida digital
pinMode(inPin, INPUT); // Inicializa el pin 7 como entrada digital
}
void loop() {
value = digitalRead(inPin); // Lee el valor de la entrada digital
Página 91/400
digitalWrite(ledPin, value);
}
Página 92/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 93/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 94/400
Practica 10).- Lectura de Entrada Analógica por Potenciómetro.
Objetivo: Desarrollar un Programa que lea la entrada analógica de arduino.
Tarea 6 Investigar sobre Contador Digital programable

Complemento Apuntes 6 Sobre Control digital de un contador.


Página 95/400
Desarrollo: 6. Potenciómetro: Lectura de señal Analógica
Descripción:
El potenciómetro es un dispositivo electromecánico que consta de una resistencia
de valor fijo sobre la que se desplaza un contacto deslizante, el cursor, que la
divide eléctricamente. Como se muestra en el siguiente gráfico:
Vout=((R1/(R1+R2))*Vin (Aplicando la ley de Ohm)

Un potenciómetro es especificado por su resistencia total, R, entre los terminales
externos 1 y 3; El movimiento del cursor origina un cambio en la resistencia
medida entre el terminal central, 2, y uno cualquiera de los extremos.
Este cambio de resistencia puede utilizarse para medir desplazamientos lineales o
angulares de una pieza acoplada al cursor.
Se conectan en paralelo al circuito y se comporta como un divisor de tensión.
Un potenciómetro también puede ser usado como una resistencia variable (o
reóstato) de dos terminales, en ese caso, se cortocircuitan dos de las tres patas
del potenciómetro. Ejemplo:
Listado de componentes:
1 Potenciómetro de 10kΩ
1 Diodo LED
Varios cables
Página 96/400
Circuito:
Se conectan tres cables a la tarjeta Arduino. El primero va a tierra desde el
terminal 1 del potenciómetro. El terminal 3 va a la salida de 5 voltios. El terminal 2
va desde la entrada analógica #2 hasta el terminal interno del potenciómetro.
Girando el dial o ajustando el potenciómetro, cambiamos el valor de la resistencia
variable. Esto produce oscilaciones dentro del rango de 5 y 0 voltios, que son
capturados por la entrada analógica.
Página 97/400
Programa
/* Potenciómetro
* ------------------
*
* enciende y apaga un LED conectado al pin digital #13;
* La cantidad de tiempo que el LED parpadeará depende del
* valor obtenido mediante analogRead(). En este caso al pin 2 *
*
* Created 1 December 2005
* copyleft 2005 DojoDave <http://www.0j0.org>
* http://arduino.berlios.de
*
*/
int potPin = 2; // seleccionar el pin de entrada analógico para el potenciómetro
int ledPin = 13; // seleccionar el pin de salida digital para el LED
int val = 0; // variable para almacenar el valor capturado desde el sensor
void setup() {
pinMode(ledPin, OUTPUT); // declara el ledPin en modo salida
}
void loop() {
val = analogRead(potPin); // lee el valor del sensor
digitalWrite(ledPin, HIGH); // enciende LED
delay(val); // detiene el programa por un tiempo “val”
digitalWrite(ledPin, LOW); // apaga el LED
delay(val); // detiene el programa por un tiempo “val”
}
Página 98/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 99/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 100/400
Practica11).- Coche Fantástico.
Objetivo: Desarrollar Programa que sea capaz de prender en secuencia ida y
vuelta unos leds.
Tarea 7: Investigar sobre Secuencias Digitales Ascendentes y Descendentes

Complemento Apuntes 7 Sobre Registrios de corrimiento 74164


Página 101/400
Desarrollo: 7. El coche fantástico
Hemos denominado este ejemplo como "El coche fantástico" en memoria de la
serie de TV de los años 80 en la que el famoso David Hasselhoff tenía una
máquina de IA conduciendo su Pontiac. El coche estaba equipado con gran
cantidad de LED-s de todos los tamaños posibles que realizaban efectos
parpadeantes.
De esta manera hemos decidido, con el objetivo de aprender programación
secuencial y buenas técnicas para programar la placa E/S, sería interesante usar
el coche fantástico como una metáfora.
Este ejemplo hace uso de 6 LED-s conectados a los PIN 2 a 7 de la placa
mediante resistencias de 220 Ohmios. El primer código de ejemplo hace
parpadear a los LED en secuencia de uno en uno, utilizando sólo las funciones
digitalWrite(pinNum,HIGH/LOW) y delay(time). El segundo ejemplo muestra cómo
usar una secuencia de control for(;;;) para hacer lo mismo, pero en menos líneas
de código. El tercer y último ejemplo se centra en el efecto visual de apagar y
encender los LED-s de una forma más suave.
6 LED-s.
6 resistencias de 220 Ohmios.
Una placa protoboard.
Cables para realizar las conexiones
Página 102/400
Programa
/* El coche fantástico 1
* ---------------------
* Básicamente una extensión del LED parpadeante.
* (cleft) 2005 K3, Malmo University
* @author: David Cuartielles
* @hardware: David Cuartielles, Aaron Hallborg
*/
int pin2 = 2; // PIN-es de los LED
int pin3 = 3;
Página 103/400
int pin4 = 4;
int pin5 = 5;
int pin6 = 6;
int pin7 = 7;
int timer = 100; // Temporizador
void setup(){
pinMode(pin2, OUTPUT); // Configuración de los PIN-es como salida
pinMode(pin3, OUTPUT);
}
void loop() {
digitalWrite(pin2, HIGH); // Enciende y apaga secuencialmente LED-s
delay(timer);
digitalWrite(pin2, LOW);
delay(timer);
digitalWrite(pin3, HIGH);
delay(timer);
delay(timer);
delay(timer);
delay(timer);
delay(timer);
delay(timer);
Página 104/400
delay(timer);
delay(timer);
delay(timer);
delay(timer);
delay(timer);
delay(timer);
delay(timer);
delay(timer);
delay(timer);
delay(timer);
delay(timer);
delay(timer);
}
Página 105/400
En este caso las luces se encenderán y apagaran todas en un sentido y luego ,
acabada la secuencia en sentido contrario.
* ---------------------
* Reduciendo las líneas de código usando un for(;;).
*/
int pinArray[] = {2, 3, 4, 5, 6, 7}; // Define el array de pines
int count = 0; // Contador
Página 106/400
void setup(){
for (count=0;count<6;count++){ // Configuramos todos los PIN-es
pinMode(pinArray[count], OUTPUT);
}
}
void loop() { // Enciende y apaga secuencialmente los LED-s
for (count=0;count<6;count++) { // utilizando la secuencia de control for(;;)
digitalWrite(pinArray[count], HIGH); // Recorrido de ida
delay(timer);
digitalWrite(pinArray[count], LOW);
delay(timer);
}
for (count=5;count>=0;count--) {
digitalWrite(pinArray[count], HIGH); // Recorrido de vuelta
delay(timer);
delay(timer);
}
En este caso el efecto que se crea es una estela visual muy vistosa.
Página 107/400
Programa
* ---------------------
*
* Este ejemplo se centra en el efecto visual.
*
Página 108/400
*/
int pinArray[] = {2, 3, 4, 5, 6, 7}; // PIN-es
int count = 0; // Contador
void setup(){
for (count=0;count<6;count++) { // Configuramos todas los PIN-es de golpe
pinMode(pinArray[count], OUTPUT);
}
}
void loop() {
for (count=0;count<5;count++) { // Enciende los LED creando una estela
visual
digitalWrite(pinArray[count], HIGH);
delay(timer);
digitalWrite(pinArray[count + 1], HIGH);
delay(timer);
delay(timer*2);
}
for (count=5;count>0;count--) {
digitalWrite(pinArray[count], HIGH);
delay(timer);
digitalWrite(pinArray[count - 1], HIGH);
delay(timer);
delay(timer*2);
}
}
Página 109/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 110/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 111/400
Practica 12).- Estrella Fugas.
Objetivo: Desarrollar un programa que dibuje una estrella con estela.
Tarea 8: Investigar sobre contadores digitales.

Complemento Apuntes 8 Sobre circuito 4017.


Página 112/400
Desarrollo: 8. Estrella fugaz
Descripción del ejercicio Este ejercicio muestra cómo realizar un rayo de luz, o
más poéticamente, una estrella fugaz, moviéndose a través de una línea de LEDs.
Podremos configurar tanto la velocidad de de la estrella, así como la longitud de la
cola. No es muy elegante porque la cola brilla con la misma intensidad que la
estrella, y al final, parecerá como si un rayo sólido cruzase la línea de LED-s.
11 LED-s.
11 resistencias de 220 Ohmios.
Una placa protoboard.
Página 113/400
¿Cómo funciona?
Hay que conectar 11 LED-s a los pines digitales de la placa a través de
resistencias de 220 Ohmios tal y como se muestra en la imagen superior.
El programa comienza encendiendo LED-s hasta que llegue al número de LED-s

establecido para la cola. En ese momento seguirá encendiendo LED-s hacia la
izquierda (si se monta tal y como se muestra en la fotografía inferior), para
mantener el movimiento de la estrella, al mismo tiempo que apaga LED-s por la
derecha, para asegurarnos de que vemos la cola. De otra forma seguiría
encendiendo LED-s hasta encenderlos todos. Esto ocurre cuando el tamaño de la
cola es igual o mayor que el número de LED-s.
El tamaño de la cola debería ser relativamente pequeño en comparación con el
número de LED-s de forma que podamos ver la estrella.
Programa
/* Estrella fugaz
*--------------
* Este programa es una variante del ejemplo del coche fantástico. Muestra
mediante
* un loop una estrella fugaz que es dibujada en una línea de LED-s
* directamente conectados a la placa Arduino. Puedes controlar la velocidad a la
que
* la estrella se mueve gracias a una variable llamada "waitNextLed". También
* puedes controlar la longitud de la cola de la estrella a través de la variable "tail
* length"
* @author: Cristina Hoffmann
* @hardware: Cristina Hofmann
*/
// Variable declaración
// Declaración de los PIN-es mediante un array
int pinArray [] = { 2,3,4,5,6,7,8,9,10,11,12 };
Página 114/400
int controlLed = 13; // LED de control
int waitNextLed = 100; // Tiempo antes de encender el siguiente LED
// Número de LED-s que permanecen encendidos antes de empezar a apagarlos
para
//formar la cola
int tailLength = 4;
// Número de LED-s conectados (que es también el tamaño del array)
int lineSize = 11;
void setup() // Configuración de los PIN-es como salida digital
{
int i;
pinMode (controlLed, OUTPUT);
for (i=0; i< lineSize; i++)
{
pinMode(pinArray[i], OUTPUT);
}
}
void loop()
{
int i;
// Se establece la longitud de la cola en un contador
int tailCounter = tailLength;
// Se enciende el LED de control para indicar el inicio del loop
digitalWrite(controlLed, HIGH);
for (i=0; i<lineSize; i++)
{
digitalWrite(pinArray[i],HIGH); // Se encienden consecutivamente los LED
// Esta variable de tiempo controla la velocidad a la que se mueve la estrella
delay(waitNextLed);
if (tailCounter == 0)
{
Página 115/400
// Se apagan los LED-s en función de la longitud de la cola.
digitalWrite(pinArray[i-tailLength],LOW);
}
else
if (tailCounter > 0)
tailCounter--;
}
for (i=(lineSize-tailLength); i<lineSize; i++)
{
digitalWrite(pinArray[i],LOW); // Se apagan los LED
// Esta variable de tiempo controla la velocidad a la que se mueve la estrella
delay(waitNextLed);
}
}
Página 116/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 117/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 118/400
Practica 13).- Desarrollar un programa de un contador de eventos.
Objetivo: Desarrollar programa que pueda contener la cuenta de los eventos que
van pasando en un pulsador.
Tarea 9: Investigar contador de eventos

Complemento Apuntes Investigar sobre contadores decimales.


Página 119/400
Desarrollo: 9. Contador
Se trata de contar las veces que se pulsa un botón conectado en la entrada 7 de
Arduino a la vez que cada vez que contamos encendemos el led conectado en la
salida 13. El valor de la variable que almacena el número de impulsos generados
se envía al PC para que se visualice en la pantalla.
Página 120/400
Progama
/* Programa Contador
* -----------
*
* Detecta si el botón conectado a la entrada 7 ha sido presionado y enciende el
LED
* Envía al PC el valor de la variable de cuenta ""Contador" vía puerto serie.
*
* Christian Nold & Erica Calogero
*
*/
int LED = 13;
int Boton = 7;
int valor = 0;
int contador = 0;
int estadoanteriorboton = 0;
void setup()
{
beginSerial(9600); // Configura velocidad de transmisión a 9600
pinMode(LED, OUTPUT); // inicializa como salida digital el pin 13

pinMode(Boton, INPUT); // inicializa como entrada digital el 7
}
void loop()
{
valor = digitalRead(Boton); // lee el valor de la entrada digital pin 7
digitalWrite(LED, valor);
if(valor != estadoanteriorboton){
if(valor == 1){
contador++;
Página 121/400
printInteger(contador);
serialWrite(10);
serialWrite(13);
}
}
estadoanteriorboton = valor;
}
Podríamos prescindir de la resistencia colocada con el pulsador si habilitásemos la
resitencia interna Pull-up de la entrada PIN7 en ese caso el circuito quedaría como
el siguiente:
El programa en este caso seria muy parecido al anterior. Observese que ahora al
pulsar el boton introducimos un “=” en el PIN7 por lo tanto si quiero que se
encienda la salida PIN13 debo escribir en ella el valor leido del pulsador negado
es decir “!valor”
Página 122/400
/* Programa Contador Modificado
* -----------
*
LED
*
* Christian Nold & Erica Calogero J.M. Ruiz
*
*/
int LED = 13;
int Boton = 7;
int valor = 0;
int contador = 0;
void setup()
{
digitalWrite(Boton,HIGH); // Habilitamos la resitencia interna Pull-up del PIN7
}
void loop()
{
valor = digitalRead(Boton); // lee el valor de la entrada digital pin 7
digitalWrite(LED, !valor); // Escribimos en la salida el bvlaor leido negado
if(valor == 1){
contador++;
serialWrite(10);
Página 123/400
serialWrite(13);
}
}
}
Página 124/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 125/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 126/400
Practica 14).- Contador de 0 a 10.
Objetivo: Desarrollar un programa de contador digital.
Tarea 10: Investigar sobre Contadores Digitales

Complemento Apuntes 10 Tipos de Contadores


Página 127/400
10 Contador de 0 a 10
Se trata de realizar una variación sobre el ejemplo anterior de tal manera que
cuando el valor del contador llegue a 10 se ponga a cero y comience de nuevo.
Página 128/400
Progama
/* Programa Contador de 0 a 10
* -----------
*
LED
*
* Christian Nold & Erica Calogero
*
*/
int LED = 13;
int Boton = 7;
int valor = 0;
int contador = 0;
void setup()
{

}
void loop()
{
valor = digitalRead(Boton); // lee el valor de la entrad digital pin 7
digitalWrite(LED, valor);
if(valor == 1){
contador++;
Página 129/400
serialWrite(10);
serialWrite(13);
if (contador==10) { // Limita la cuenta al valor 10
contador=0;
}
}
}
}
Página 130/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 131/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 132/400
Practica 15).- Entrada Analógica
Objetivo: Desarrollar un programa que configure un canal de entrad analógico pin
5 y enviar el valor leído al PC para visualizarlo.
Tarea 11: Investigar sobre Programación de comunicación PC

Complemento Apuntes 11 Sobre Lectura de Entradas Analógicas.


Página 133/400
11. Entrada Analógica
Se trata de configurar un canal de entrad analógico pin 5 y enviar el valor leído al
PC para visualizarlo
Programa
/* Entrada Analógica */
int potPin = 5; // selecciona el pin de entrada para colocar el potenciómetro
int val = 0; // variable para almacenar el valor leído por la entrada analógica
void setup() {
beginSerial(9600);
}
void loop() {
val = analogRead(potPin); // lee el valor del canal de ENTRADA analógica
printInteger(val); // Envía al PC el valor analógico leído y lo muestra en pantalla
serialWrite(10);
delay(100);
}
Página 134/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 135/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 136/400
Practica 16).- Simular de una vela.
Objetivo: Desarrollar un programa para arduino que hace uso de la instrucción
para generar un número aleatorio que lo asignamos a una salida analógica PWM y
otro número que lo asociamos a la variable de temporización.
Tarea 12: Investigar sobre ¿Control PWM?

Complemento Apuntes 12 Sobre Números Aleatorios.


Página 137/400
12. Simulación de la luz de una vela
Se trata de simular el movimiento de la llama de una vela. Hacemos uso de la
instrucción para generar un numero aleatorio que lo asignamos a una salida
analógica PWM y otro número que lo asociamos a la variable de temporización
(tiempo que esperamos para cambiar el valor de la salida).
/*
* Simula luz de vela
* Saca por una de las salidas del puerto PWM un valor aleatorio que activa un LED
*
* 2007 Tod E. Kurt <tod@todbot.com>
int ledPin = 9; // selecciona el puerto PWM

int val = 0; // define y pone a cero la variable "brillo"
int delayval = 0; // define el intervalo de cambio de valor de salida
void setup() {
randomSeed(0); // inicializa el generador de números aleatorios
Página 138/400
pinMode(ledPin, OUTPUT); // declara el pin de SALIDA pin 9
}
void loop() {
val = random(100,255); // genera un número aleatorio entre 100 y 255 que asigna
a la variable val
analogWrite(ledPin, val); // envía ese valor a la salida pin 9
delayval = random(50,150); // genera un numero aleatorio entre 30 y 100 y lo
asigna a la variable de temporización
delay(delayval); // espera un tiempo delayval medido en milisegundos
}
Página 139/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 140/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 141/400
Practica 17).- Indicador de Nivel.
Objetivo: construir un indicador de nivel que sea capaz de medir el valor de una
señal de entrada generada por un potenciómetro desde una entrada analógica.
Tarea 13: Investigar sobre Control de Nivel

Complemento Apuntes 13 Sobre Tipos de Sensores de Nivel


Página 142/400
13. Construcción de un indicador de nivel (vúmetro con diodos led)
Se trata de construir un indicador de nivel que sea capaz de medir el valor de una
señal de entrada generada por un potenciómetro desde una entrada analógica.
Se establecerán 3 diodos Led conectados a las salidas PIN6, PIN7 y PIN8. La
entrada la conectaremos en la entrada analógica PIN 1 (analog IN1)
int ledPin1 = 8; // Selección de PIN para cada LED

int ledPin2 = 7;
int ledPin3 = 6;
int inPin= 1; // selecciona la entrada analógica 1 (potenciómetro)
void turn_off() { //Apaga los 3 LEDS

Página 143/400
}
void setup() {
pinMode(ledPin1, OUTPUT); // declara LEDs como salidas
turn_off(); //
}
void loop(){
int val;
val= analogRead(inPin); // lee el valor de la señal analógica
turn_off();apaga los tres LED
// Si el valor de la señal medida es > 256 enciende LED del PIN8
if (val>= 256) digitalWrite(ledPin1, HIGH);
}
Página 144/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 145/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 146/400
Practica 18).-Encender y Apagar una luz con un control analógico.
Objetivo: Desarrollar un programa que envíe hacia la salida 9 un valor analógico
ascendente y descendente cíclicamente comprendido entre 0 y 255 en
incrementos de 5.
Tarea 14: Investigar sobre Potenciómetro Digital

Complemento Apuntes 14 Sobre Encendido con Entradas Analógicas.


Página 147/400
14. Encendido y apagado de una luz de manera analógica
Se trata de que enviemos hacia la salida 9 un valor analógico ascendente y
descendente cíclicamente comprendido entre 0 y 255 en incrementos de 5.
Para la realización de este ejercicio se debe empleará una estructura de
programación tipo for que realice el incremento o decremento de una variable
entre 0-255 y 255-0 con un valor te retardo entre cambio de valor de 30 mseg.
En la figura vemos una repr4sentacion e l valor de la señal de salida en el PIN 9.

Téngase en cuenta que el valor 255 equivale a 5 voltios y el valor 0 a 0 voltios.
Esquema
Página 148/400
Programa
// Salida Analógica Cíclica

// by BARRAGAN <http://people.interaction-ivrea.it/h.barragan>
int value = 0; // Valor a sacar por la salida analógica PIN 9
int ledpin = 9; // Salida analógicas PIN 9
void setup()
{
// nothing for setup
}
void loop()
{
for(value = 0 ; value <= 255; value+=5) // Variación de la variable se salida ente el
MIN yMAX
{
analogWrite(ledpin, value); // Enviar valor a la salida (entre 0 y 255)
delay(30); // Esperar 30 ms para ver el efecto de variación
}
for(value = 255; value >=0; value-=5) // Variación de la variable de salida entre
MAX y MIN
{
analogWrite(ledpin, value);
delay(30);
}
}
Página 149/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 150/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 151/400
Practica 19).- Control de la Iluminación de una lámpara.
Objetivo: Desarrollar un Programa controle el grado de iluminación de una lámpara
(simulada con un LED) mediante un pulsador.
Tarea 15 Investigar sobre Control Digital programable

Complemento Apuntes 15 Sobre Control analógico programable.


Página 152/400
15. Control de la iluminación de una lámpara.
Con esta aplicación se pretende controlar el grado de iluminación de una lámpara
(simulada con un LED) mediante un pulsador.
Funcionamiento:
Si no pulsamos el pulsador (entrada 0) la lámpara incrementar y decrementar su
brillo o nivel de iluminación.
Si pulsamos (entrada 1) la lámpara se encenderá y apagará con una cadencia de
50 mseg.
Esquema
Página 153/400
Programa
/* Control de iluminación mediante Pulsador */
int ledPin = 9; // Selección del PIN de salida Analógica
int inputPin = 2; // Selección del PIN para la entrada de pulsador
int val = 0; // variable para leer el estado del pulsador
int fadeval = 0;
void setup() {
pinMode(ledPin, OUTPUT); // designación de salida Analógica
pinMode(inputPin, INPUT); // designación de pulsador de entrada
}
void loop(){
val = digitalRead(inputPin); // leer valor de entrada
if (val == HIGH) { // Botón pulsado
digitalWrite(ledPin, LOW); // puesta a "0" de la salida
delay(50);
digitalWrite(ledPin, HIGH); // puesta a "1" de la salida
delay(50);
}
else { // Si se presiona el boton
for(fadeval = 0 ; fadeval <= 255; fadeval+=5) { // valor de salida analógica asciende
de min a max)
analogWrite(ledPin, fadeval); // fija el valor en la salida ( desde 0-255)
delay(100);
}
for(fadeval = 255; fadeval >=0; fadeval-=5) { // valor de salida analógica desciende
(desde max to min)
analogWrite(ledPin, fadeval);
delay(100);
}
}
}
Página 154/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 155/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 156/400
Practica 20).- Sensor de Luz LDR.
Objetivo: Desarrollar Programa que cuando menor luz reciba el LDR menor luz
emita el led y entre más luz reciba la LDR mas prende el led.
Tarea 16: Investigar sobre Sensores LDR

Complemento Apuntes 16 Sobre Tipos de Sensores de Luz


Página 157/400
16. Sensor de Luz o LDR (Light Dependent Resistor):
Descripción: Un LDR es una resistencia variable, que varía su valor dependiendo
de la cantidad de luz que incide sobre su superficie. Cuanta más intensidad de luz
incide en la superficie de la LDR menor será su resistencia y cuanto menos luz
incide mayor será la resistencia. Suelen ser utilizados como sensores de luz
ambiental o como una fotocélula que activa un determinado proceso en ausencia o
presencia de luz.
Un sensor de luz se compone de una LDR como parte de un divisor de tensión

resistivo.
Ejemplo:
Vout=((Rbotton/(Rbottom+Rtop))*Vin
Si la LDR es usada como Rtop, como en el primer circuito, da tensión alta (HIGH)
en la salida cuando la LDR está en la luz, y una tensión baja (LOW) en la salida
cuando la LDR está en la sombra.
La acción del divisor de tensión es inversa cuando la LDR es usada como Rbottom
en lugar de Rtop, como en el segundo circuito. El circuito da tensión Baja (LOW)
en la salida cuando la LDR está en la luz, y una tensión alta (HIGH) en la salida
cuando la LDR está en la sombra. El circuito divisor de tensión dará una tensión
Página 158/400
de la salida que cambia con la iluminación, de forma inversamente proporcional a
la cantidad de luz que reciba (sensor de oscuridad).
1 LDR
1 Resistencia de 5kΩ
Un par de cables
1 Diodo LED
El esquema del circuito puede quedar de la siguiente forma:
El circuito consta de un divisor de tensión formado por la LDR y la resistencia de

5kΩ.
Página 159/400
Código:
/* Sensor de Luz LDR
* Enciende y apaga un LED (light emitting diode) conectado al pin digital #13.
Programa
* La cantidad de tiempo que el LED estará encendido y apagado depende del

* valor obtenido de analogRead().
* La salida del sensor de luz o divisor de tensión, está conectado
* a la entrada del pin 3, por lo que
* a más luz, el parpadeo del LED será menor y a menos luz el parpadeo del LED
mayor.
* (sensor de oscuridad)
*
* copyleft 2005 DojoDave <http://www.0j0.org>
* http://arduino.berlios.de
*
*/
int LightPin = 3; // selecciona el pin de entrada para el sensor de luz
int ledPin = 13; // selecciona el pin para el LED
int val = 0; // variable para almacenar el valor capturado desde el sensor
void setup() {
pinMode(ledPin, OUTPUT); // declara el ledPin en modo salida
}
void loop() {
val = analogRead(LightPin); //lee el valor del sensor
digitalWrite(ledPin, HIGH); // enciende el LED
delay(val); // detiene el programa por un tiempo
delay(val); // detiene el programa por un tiempo
}
Página 160/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 161/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 162/400
Practica 21).- Sensor de Temperatura NTC.
Objetivo: Desarrollar un programa que lea el valor de la temperatura y cuando
llegue a 500 puntos se active un led.
Tarea 17: Investigar sobre contadores digitales.

Complemento Apuntes 17 Sobre circuito 4017.


Página 163/400
17. Sensor de temperatura o NTC
Descripción: Se trata de medir la temperatura desde el PIN3 de entrada analógica
y ver si este valor supera un valor dado de 500 (medida absoluta) si supera este
valor activará la salida digital PIN13 y si no la apagara. Además queremos que se
muestre en el monitor de salida del IDE Arduino el valor leído. D sensor
utilizaremos un sensor del tipo NTC.
Un NTC o termistor NTC es una resistencia variable, que varia su valor
dependiendo de la temperatura ambiente. Cuanta mas temperatura menor será su
resistencia y cuanto menos temperatura mayor será la resistencia. Suelen ser
utilizados en alarmas.
Un sensor de temperatura se compone de un NTC como parte de un divisor de

tensión resistivo.
Ejemplo
Como alarma de incendio o sensor de calor, utilizaremos un circuito que entregue
una tensión alta cuando se detecten las condiciones de temperatura caliente.
Necesitamos poner un divisor de tensión con un termistor NTC en la posición que
ocupa Rarriba:
Como alarma de frío o sensor de frío, usaremos un circuito que dé una tensión alta
en condiciones frías. Necesitamos un divisor de voltaje con el termistor NTC en
lugar de Rbajo:
Página 164/400
1 NTC sensor de temperatura
1 Resistencia 1kΩ
1 Diodo LED
Un par de cables
Esquema del Circuito:
El circuito consta de un divisor de tensión formado por el NTC y la resistencia de
1kΩ.
Página 165/400
Programa
//Detector de valor de temperatura
int led=13;
int ntc=3;
int medida=0;
//variable que guarda el límite de temperatura al que se activa el ventilador
int nivel=500;
void setup(){
pinMode(led,OUTPUT);
pinMode(motor,OUTPUT);
beginSerial(9600);
}
//procedimiento que envía al puerto serie, para ser leído en el monitor,
void monitoriza(){
printInteger(medida); //el valor de la señal de la NTC en la entrada analógica
printString(" ");
delay(100); //para evitar saturar el puerto serie
}
void loop(){
medida=analogRead(ntc);
monitoriza();
if(medida>nivel){ //si la señal del sensor supera el nivel marcado:
digitalWrite(led,HIGH); //se enciende un aviso luminoso
}
else{ // si la señal está por debajo del nivel marcado
digitalWrite(led,LOW);
}
}
Página 166/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 167/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 168/400
Practica 22).- Sensor de Fuerza.
Objetivo: Desarrollar un circuito converta un zumbador piezoeléctrico en un sensor
de presión o fuerza utilizando este como sensor de entrada en uno de los pines de
entrada analógica de Arduino (PIN 2).
Tarea 18: Investigar sobre Sensor de Fuerza

Complemento Apuntes 18 Sobre Zumbador piezoeléctrico


Página 169/400
18. Sensor de Fuerza.
Se trata de convertir un zumbador piezoeléctrico en un sensor de presión o fuerza
utilizando este como sensor de entrada en uno de los pines de entrada analógica
de Arduino (PIN 2)
/* Sensor piezoelectrico
* -----------
* Convertir un zumbador piezoelectrico en un sensor de de fuerza
*
* Created 24 October 2006
* copyleft 2006 Tod E. Kurt <tod@todbot.com
* http://todbot.com/
*/
int ledPin = 13;
int piezoPin = 2;
int THRESHOLD = 1; // Configura valor mínimo para que se encienda la salida
PIN13
int val = 0; // variable que almacena el valor leído por el sensor
int t = 0; // valor del intervalo de medida
Página 170/400
void setup() {
pinMode(ledPin, OUTPUT);
Serial.begin(19200);
Serial.println("ready"); // indicador de espera
}
void loop() {
digitalWrite(ledPin,LOW); // indicador de reposo (esperando)
val = analogRead(piezoPin); // lectura de valor del piezoeléctrico
if( val > THRESHOLD ) { // si el valor leído es superior al mínimo establecido
digitalWrite(ledPin, HIGH); // activa salida 13
t = 0;
while(analogRead(piezoPin) > THRESHOLD) {
t++;
} // wait for it to go LOW (espera con una pequeña histéresis)
if(t>100) { // escribe en el puerto
Serial.print("knock! ");
//Serial.println(t);
}
}
}
Página 171/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 172/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 173/400
Practica 23).- Generador de Notas Musicales.
Objetivo: Desarrollar un programa que genere hasta 8 notas musicales por una de
las salidas analógicas de Arduino –PIN10-.
Tarea 20: Investigar sobre Frecuencia de notas musicales

Complemento Apuntes 20 ¿Como generar tonos con un Zumbador?


Página 174/400
19. Generador de notas musicales
Se trata de generar hasta 8 notas musicales por una de las salidas analógicas de
Arduino –PIN10-
Se debe crear un array (vector) de datos compuesto por los valores
correspondientes a las 8 notas que se pretende sacar:
int notas[] = {1915, 1700, 1519, 1432, 1275, 1136, 1014, 956};
Se deben definir también el tiempo de pausa entre nota y nota y el tiempo de
pausa de fin de secuencia de notas:
int tnota=100;
int pausa=100;
Las iteraciones para el recorrido de las 8 notas se realizan con una instrucción de
tipo for:
for(n=0;n<8;n++)
El tiempo de activado y desactivado de la salida del zumbador también se
resuelve con un bucle for:
for(m=0;m<=tnota;m++){
Esquema/Organigrama
Página 175/400
Programa
// Generador de Notas Musicales
int piezo=10;
int notas[] = {1915, 1700, 1519, 1432, 1275, 1136, 1014, 956}; //cadena con los
tiempos que corresponden a las distintas notas
int n=0;
int m= 0;
int tnota=100; //nº de repeticiones del pulso. Nos da la duración de la nota
int pausa=100;
void setup() {
pinMode(piezo,OUTPUT);
}
void loop(){
for(n=0;n<8;n++){ //iteración que recorre la lista con las duraciones de los pulsos
de cada nota
digitalWrite(piezo,HIGH);
delayMicroseconds(notas[n]); //Tiempo en microsegundos que está a 5V la salida
del piezoeléctrico
digitalWrite(piezo,LOW);
delayMicroseconds(notas[n]); //Tiempo en microsegundos que está a 0V la salida
del piezoeléctrico
}
delay(pausa); //tiempo en silencio entre escalas
}
}
Página 176/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 177/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 178/400
Practica 24).- Tocar tonos desde el puerto serial
Objetivo: Desarrollar un programa para reproducir tonos, aprovechando la
capacidad que tiene el procesador para producir señales PWM y así reproducir
música..
Tarea 20: Investigar sobre Array (vectores y matrices)

Complemento Apuntes 20 Sobre Frecuencia de los PWM en arduino.


Página 179/400
20. Toca tonos desde el puerto serial
En este ejercicio usaremos un Piezo eléctrico para reproducir tonos,
aprovechando la capacidad que tiene el procesador para producir señales PWM y
así reproducir música.
Un piezo eléctrico no es más que un dispositivo que puede ser usado tanto para
reproducir o detectar tonos. En nuestro ejemplo estamos conectando el piezo en el
pin número 9, que permite enviar una señal PWN .
Los tonos pueden ser generados a partir de cualquier programa capaz de enviar
valores ASCII a través del puerto serial. Programas de Terminal, Processing, Pure
Data o Director, pueden ser usados para generar los tonos. En nuestro caso los
caracteres ASCII los enviaremos por la ventana de dialogo del IDE Arduino.
Ejemplo de la conexión de un piezo eléctrico al pin 9, y utilizaremos 8 tonos tal

como se indica en el código del programa. Si pulsamos cualquier otra letra que no
sea de las que tienen asignados tonos el zumbador deja de emitir tonos.
Página 180/400
Aspecto del IDE Arduino enviando caracteres ASCII a la tarjeta para que estos se
conviertan en tonos
Página 181/400
Programa
/* Teclado Serial
* Programa para reproducir tonos dependiendo de los datos que vengan del
Puerto
* serie. El cálculo de los tonos se realiza de acuerdo a la siguiente operación:
*
* pulsoAlto = 1/(2 * frecuenciaTono) = periodo / 2
*
* Donde los tonos son descritos como en la siguiente tabla:
*
* tecla frecuencia periodo PW (pulsoAlto)
* c 261 Hz 3830 1915
* d 294 Hz 3400 1700
* e 329 Hz 3038 1519
* f 349 Hz 2864 1432
* g 392 Hz 2550 1275
* a 440 Hz 2272 1136
* b 493 Hz 2028 1014
* C 523 Hz 1912 956
* Cualquier otra letra provoca el silencio del zumbador
* (cleft) 2005 D. Cuartielles para K3
* Trad. Juan C. Carvajal. Modificado J.M.Ruiz
*/
int ledPin = 13; int speakerOut = 9; byte names[] ={'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C'}; int
tones[] = {1915, 1700, 1519, 1432, 1275, 1136, 1014, 956}; byte val = 0; int
serByte = -1; int statePin = LOW; int count = 0;
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(speakerOut, OUTPUT);
beginSerial(9600);
}
Página 182/400
void loop() {
digitalWrite(speakerOut, LOW);
serByte = serialRead();
if (serByte != -1) {
val = serByte;
printByte(val);
statePin = !statePin;
digitalWrite(ledPin, statePin);
}
for (count=0;count<=8;count++) {
if (names[count] == val) {
digitalWrite(speakerOut, HIGH);
delayMicroseconds(tones[count]);
delayMicroseconds(tones[count]);
}
else
}
}
Página 183/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 184/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 185/400
Practica 25).- Timbre de llamada.
Objetivo: Desarrollar un programa para arduino que simule un timbre a través de
un zumbador (salida 10) que emita dos tonos recogidos de una colección de ocho
tonos.
Tarea 21: Investigar sobre ¿Control PWM?

Complemento Apuntes 21 Sobre Tipos de Zumbadores.


Página 186/400
21. Timbre de llamada
Se trata de realizar un timbre a través de un zumbador (salida 10) que emita dos
tonos recogidos de una colección de ocho tonos, por ejemplo el tono 0 y el tono 6.
El timbre se activa mediante un pulsador conectado en el PIN5 (entrada digital).
int notas[] = {1915, 1700, 1519, 1432, 1275, 1136, 1014, 956};
tono0=1915 tono6=1014
Para la resolución de este ejemplo se sugiere crear un procedimiento llamado nota
al que se incoará cuando se pulse el pulsador conectado en el PIN 5
Esquema/organigrama
Programa
//Timbre de llamada
Página 187/400
int notas[] = {1915, 1700, 1519, 1432, 1275, 1136, 1014, 956}; //definición de
matriz de 8 notas
int puls=5; // designación del pulsador de llamada
int zumb=10; // designación de la salida hacia el zumbador
int tnota=150;
int n=0;
int m=0;
void setup (){
for(n=0;n<4;n++){
pinMode(zumb,OUTPUT);
pinMode(puls,INPUT);
}
}
void nota(){ // rutina que genera los tonos de llamada
digitalWrite(zumb,HIGH);
delayMicroseconds(notas[n]);
digitalWrite(zumb,LOW);
delayMicroseconds(notas[n]);
}
}
void loop(){
if(digitalRead(puls)==HIGH){
n=0; //elegimos la primera nota del timbre
nota(); //que aquí es la primera de la cadena
delay(200);
n=6; //elegimos la segunda nota del timbre
nota(); //que aquí es la sexta de la cadena
delay(200);
}
}
Página 188/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 189/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 190/400
Practica 26).- Control de Encendido de un led vía puerto Serie USB.
Objetivo: Desarrollar un programa que realizar que active y desactive una salida
digital (PIN13) un número de veces que indicaremos mediante un número a través
del terminal del IDE Arduino.
Tarea 22: Investigar sobre Comunicación serial con arduino

Complemento Apuntes 22 Sobre Consola de comunicación serie


Página 191/400
22. Enciende y apaga un número de veces un LED
Se trata de realizar un ejemplo que active y desactive una salida digital (PIN13) un
número de veces que indicaremos mediante un número a través del terminal del
IDE Arduino.
Aspecto del terminal del IDE Arduino al iniciar el programa
Página 192/400
Aspecto del terminal del IDE Arduino una vez generados los 3 impulsos por el
terminal PIN13
Solución:
/*
* Impulsos programados
* -----------------
* Cambia de estado ON Off un lED conectado en el una salida digital
* pin 13. El se encenderá y apagará tantas veces como se indique mediante un
digito * ASCII leído desde el puerto serie.
*
* Created 18 October 2006
* copyleft 2006 Tod E. Kurt <tod@todbot.com>
* http://todbot.com/
*
* based on "serial_read_advanced" example
*/
int ledPin = 13; // selecciona el pin para el LED
int val = 0; // variable que almacena el valor leído del puerto
void setup() {
pinMode(ledPin,OUTPUT); // declara el PIN del LED como salida
Serial.begin(19200); // conecta con el puerto serie a la velocidad de 19200
Serial.println("Bienvenido al Generador de Impulsos Programados");
}
void loop () {
val = Serial.read(); // lee el numero del puerto (una sola cifra)
//si el valor leído es un solo digito se ejecuta el programa
if (val > '0' && val <= '9' ) {
val = val - '0'; // convierte el carácter leído en un numero
for(int i=0; i<val; i++) {
Serial.println("Encendido!");
digitalWrite(ledPin,HIGH); // enciende el LED
Página 193/400
delay(150); // espera
delay(150); // espera
}
}
}
Página 194/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 195/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 196/400
Practica 27).-Control de un motor de CD.
Objetivo: Desarrollar un programa que controle la velocidad de un motor de cd
mediante la utilización de un transistor BD137.
Tarea 23: Investigar sobre Control de motores de CD

Complemento Apuntes 23 Sobre Puente H.


Página 197/400
23. Control de un motor de cc con un transistor
Con este ejemplo vamos a controlar la velocidad de un motor de cc mediante la
utilización de un transistor BD137. Se trata de utilizar la posibilidad de enviar una
señal de PWM a una de las salidas configurables como salidas analógicas (para
ATMEGA 168
Téngase en cuenta que el motor debe ser de bajo consumo por dos motivos:
primero porque si alimentamos en las pruebas desde el conector USB no
debemos sacar demasiada corriente del ordenador y segundo porque el transistor
es de una corriente limitada.
El diodo 1N4001 se coloca como protección para evitar que las corrientes inversas
creadas en el bobinado del motor puedan dañar el transistor.
Página 198/400
La tensión que sacaremos a la salida 10 (analógica tipo PWM) variara en forma de
rampa ascendente y descendente de manera cíclica tal como vemos en la figura.
Este efecto lo conseguimos con una estructura del tipo for:
for(valor = 0 ; valor <= 255; valor +=5) (ascendente)
for(valor = 255; valor >=0; valor -=5) (descendente)
Obsérvese que los incrementos del valor de la tensión van de 5 en 5 y tenemos
que considerar que 0v equivale a 0 y 5 v. equivale a 255.
Programa:
int valor = 0; // variable que contiene el valor a sacar por el terminal analógico
int motor = 10; // motor conectado al PIN 10
void setup() { } // No es necesario
void loop() {
for(valor = 0 ; valor <= 255; valor +=5) {
// se genera una rampa de subida de tensión de 0 a 255 es decir de 0 a 5v
analogWrite(motor, valor);
delay(30); // espera 30 ms para que el efecto sea visible
}
for(valor = 255; valor >=0; valor -=5) {
// se genera una rampa de bajada de tensión de 255 a 0 es decir de 5 a 0v
analogWrite(motor, valor);
delay(30);
}
}
Página 199/400
Variante del montaje: Control de la velocidad mediante un potenciómetro
Se trata de controlar la velocidad a nuestro gusto es decir mediante un
potenciómetro que se coloca en una de las entradas analógicas y en función del
valor que se lea en la entrada así girará mas o menos rápido el motor.
Programa:
int valor = 0; // variable que contiene el valor a sacar por el terminal analógico
int motor = 10; // motor conectado al PIN 10
int potenciometro=0; // Se define la entrada analógica
void loop() {
valor = analogRead(potenciometro); // se lee el valor de la entrada analógica y se
asigna a val
analogWrite(motor, valor); // Se manda a la salida analógica 0 el valor leído
delay(30); // espera 30 ms para que el efecto sea visible
}
Página 200/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 201/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 202/400
Practica 28).- Control de Motor CD con driver 293D.
Objetivo: Desarrollar un Programa para mover un motor de cd haciendo uso de un
CI de potencia que es específico para estas aplicaciones.
Tarea 24 Investigar sobre CI 293D

Complemento Apuntes 24 Sobre Control PWM programable.


Página 203/400
24. Control de un motor de cd con el driver L293D
Con esta aplicación vamos a mover un motor de cd haciendo uso de un CI de
potencia que es específico para estas aplicaciones. El circuito podrá mover hasta
dos motores, nosotros solo lo haremos con uno.
Como ventana en este montaje podremos mover el motor en los dos sentido de
giro cosa que con el anterior montaje no podíamos.
El funcionamiento será como el primer montaje del motor anterior es decir vamos
a crear una rampa de subida de tensión y una de bajada con el fin de que el motor
modifique su velocidad de modo automático.
Control o Driver de un motor de continua:
Los dos parámetros que queremos controlar de un motor de continua, es su
dirección de giro y su velocidad. La dirección se controla cambiando su polaridad.
En cambio, para su velocidad, debemos utilizar la técnica de modulación por
ancho de pulso-PWM.
Aquí hay algunos gráficos donde se muestra la relación entre la señal de pulsos
(PWM) y el voltaje efectivo:
Cuando el tiempo que el pulso está activo es la mitad del periodo de la señal o el
parámetro duty cycle está al 50%, el voltaje efectivo es la mitad del voltaje total de
entrada.
Página 204/400
Cuando el duty cycle es reducido al 25%, el voltaje efectivo es un cuarto del
voltaje total de entrada. Entonces la velocidad del motor disminuye.
De esta forma controlando el duty cycle o el tiempo que el pulso está activo
(frecuencia), podemos controlar la velocidad del motor de continua.
Una forma de realizar dicho control en Arduino, es utilizando la salida analógica
PWM. Hay que recordar que la señal de salida PWM (pines 9,10) es una señal de
frecuencia constante (30769 Hz) y que sólo nos permite cambiar el "duty cycle" o
el tiempo que el pulso está activo (on) o inactivo (off), utilizando la función
analogWrite().
La otra forma es generando señales PWM utilizando la capacidad del
microprocesador a través de la función digitalWrite ().
Si queremos controlar simultáneamente la velocidad y dirección de un motor,
necesitamos utilizar un circuito integrado o chip llamado de forma general como
"puentes H", por ejemplo como el L293D.
Chip L293D/B(puente H):
Es un circuito integrado o chip, que puede ser utilizado para controlar
simultáneamente la velocidad y dirección de dos motores de continua (contiene
dos puentes H). La diferencia entre el modelo L393D y L293B, es que el primero
viene con diodos de protección que evita los daños producidos por los picos de
voltaje que puede producir el motor.
Página 205/400
Contiene 4 pines digitales (2,7,10, 15) para controlar la dirección de los motores.
Los pines "enable" (1,9) admiten como entrada una señal PWM, y se utiliza para
controlar la velocidad de los motores con la técnica de modulación de ancho de
pulso.
Los motores van conectados entre uno de los pines 3, 6, 11, o 14.
La tensión Vss es la que alimentará o dará potencia al motor.
Montaje Básico: Control simple de un motor con el CI L293 a velocidad constante
En un primer lugar sólo vamos a demostrar el control de la velocidad de un motor
de continua a través del integrado L293D. Para ello fijamos los pines de control de
dirección a 5v y 0v,de forma que sólo girará en un sentido. Si queremos cambiar el
sentido, sólo será necesario cambiar dicha polarización.
Programa
Página 206/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 207/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 208/400
Practica 29).- Control de giro de un motor cd CD opción 1.
Objetivo: Desarrollar Programa que Controle el giro de un motor de CD.
Tarea 25: Investigar sobre Tipos de Puente H

Complemento Apuntes 25 Sobre Control de motores de CA (Drimmer)


Página 209/400
25. Control de un motor: velocidad variable y sentido de giro variable (1ª opción)
Esquema
Programa
// Control de Motor con driver L293D
int valor = 0; // variable que contiene el valor
int motorAvance = 10; // Avance motor --> PIN 10
int motorRetroceso = 11; // Retroceso motor --> PIN 11
void loop() {
analogWrite(motorRetroceso, 0); // Motor hacia delante ... sube la velocidad
for(valor = 0 ; valor <= 255; valor+=5) {
analogWrite(motorAvance, valor);
delay(30);
}
for(valor = 255; valor >=0; valor-=5) { // Motor hacia delante ... baja la velocidad
analogWrite(motorAvance, valor);
delay(30);
}
analogWrite(motorAvance, 0); // Motor hacia detrás ... sube la velocidad
for(valor = 0 ; valor <= 255; valor+=5) {
Página 210/400
analogWrite(motorRetroceso, valor);
delay(30);
}
for(valor = 255; valor >=0; valor-=5) { // Motor hacia detrás ... baja la velocidad
analogWrite(motorRetroceso, valor);
delay(30);
}
}
Página 211/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 212/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 213/400
Practica 30).- Control de giro de un motor cd CD opción 2.
Objetivo: Desarrollar Programa que Controle el giro de un motor de CD
Tarea 26: Investigar Control de motor por face .

Complemento Apuntes 26 Sobre Triac.


Página 214/400
26. Control de un motor: velocidad variable y sentido de giro variable (2ª opción)
Vamos a demostrar el control simultáneo de la velocidad y del sentido de un motor
de continua.
!OJO probar en Arduino con un sólo motor
Esquema
/* PWM Motor by DojoCorp <http://www.0j0.org> Demonstrates the use of analog

output pins (PWM) controlling a motor. Description of the pinout used by the motor
control board: - pwm pin 1 controls the speed on the A side of the H bridge - pwm
pin 2 controls the speed on the B side of the H bridge - digital pin 8 controls the
direction for motor B - digital pin 9 controls the direction for motor A Created 19
March 2005 */
int value = 0; // valor actual
int pwmpinA = 1; // motor A conectado a la entrada analógica pin1
int pwmpinB = 2; // motor B conectado a la entrada analógica pin 2
int dirpinA = 9; // motor A pin dirección
int dirpinB = 8; // motor B pin dirección
boolean directionA = true; // variable estado de giro del motor A
boolean directionB = true; // variable estado de giro del motor B
void setup() {
Página 215/400
// no es necesario setup
}
void loop() {
if (directionB) {
digitalWrite(dirpinB,HIGH);
} else {
digitalWrite(dirpinB,LOW);
}
directionB = !directionB;
// varia velocidad de mínimo a máximo
for(value = 0 ; value <= 255; value+=5) {
// envía al pin del salida del motor A el valor de velocidad de 0 a 255
analogWrite(pwmpinA, value);
// envía al pin del salida del motor B el valor de velocidad de 0 a 255
analogWrite(pwmpinB, value);
delay(30); // espera 30 ms
}
// varia velocidad de máximo a mínimo
for(value = 255; value >=0; value-=5) {
analogWrite(pwmpinA, value);
analogWrite(pwmpinB, value);
delay(30);
}
}
Página 216/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 217/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 218/400
Practica 31).- Activar un relevador por puerto serie.
Objetivo: Desarrollar un circuito para encender una bombilla de 120V de corriente
alterna (AC) mediante un circuito de 5V de corriente continua (DC) gobernado por
Arduino.).controlado por bluetooth con un celular
Tarea 27: Investigar sobre Bluetooth

Complemento Apuntes 27 Sobre Programación APPInventor


Página 219/400
27. Utiliza un relé para encender dispositivos de 120V
Este sencillo ejemplo enseña como encender una bombilla de 120V de corriente
alterna (AC) mediante un circuito de 5V de corriente continua (DC) gobernado por
Arduino. Se puede utilizar con cualquier otro circuito de 120V con un máximo de
10A (con el relé del ejemplo).
¿Qué es un relé?
El relé es un dispositivo electromecánico, que funciona como un interruptor
controlado por un circuito eléctrico en el que, por medio de un electroimán, se
acciona un juego de uno o varios contactos que permiten abrir o cerrar otros
circuitos eléctricos independientes. (fuente: Wikipedia)
De aquí extraemos una información muy importante: Podemos separar dos
circuitos de forma que funcionen con voltajes diferentes. Uno a 5V (Arduino) y otro
a 120V (la bombilla).
Como se ve en el esquema inferior hay dos circuitos. El del cableado NEGRO
funciona a 5V de DC y el del cableado ROJO a 220V de AC.
Página 220/400
Programa
/*
Enciende y apaga una bombilla de 120V, cada 2 segundos, mediante
un relé conectado al PIN 8 de Arduino
*/
int relayPin = 8; // PIN al que va conectado el relé
void setup(){
pinMode(relayPin, OUTPUT);
}
void loop() {
digitalWrite(relayPin, HIGH); // ENCENDIDO
delay(2000);
digitalWrite(relayPin, LOW); // APAGADO
delay(2000);
}
Página 221/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 222/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 223/400
Practica EXAMEN UNIDAD 1).- Diseño de un Circuito Programable
OBJETIVOS:
Diseñar un circuito que sea capaz de realizar las funciones AND, NAND, OR y
NOR. de forma programada.
Emplear cualquiera de las compuertas universales para implementar el circuito
representado por su expresión booleana.
INVESTIGACION:
a) Cómo se puede construir la operación AND, NOR, NAND y OR
b) Buscar los diagramas lógicos de las compuertas del punto (a)
MATERIAL:
3 74LS00 NAND
3 74LS02 NOR
3 74LS04 NOT
3 74LS08 AND
3 74LS32 OR
3 74LS11 AND
1 DIP switch
4 Resistores 2.2 K
Cable para protoboard
EQUIPO:
Punta de prueba lógica.
Fuente de voltaje ( 5 V DC ).
Protoboard.
Manual ECG.
Pinzas de corte.
Pinzas de punta
Página 224/400
PROCEDIMIENTO:
Actividad 1).- Elaborar la ecuación canónica de a taba siguiente:
Actividad 2).-. Simplificarla y comprobar que la ecuación de salida realiza la misma

función que la ecuación del diagrama lógico con compuertas básicas.
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
Página 225/400
Actividad 3).-. Elaborar el diagrama lógico normal de la ecuación canónica de a
taba siguiente:
Página 226/400
Actividad 3) Armar el circuito físicamente, mostrarlo y describir el funcionamiento
que soluciona la problemática.
R:
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
R:
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
Página 227/400
Actividad 5).- Mostrar el funcionamiento de su trabajo al profesor, si tienen dudas
preguntar, pues le deberá quedar completamente claro el funcionamiento de su
circuito.
Grado: _____________________ Grupo ___________________________
Actividad 6).-Hacer su reporte a computadora siguiendo la tipografía indicada en el

Anexo A de este manual, tomando los datos de este borrador. El reporte será
UNO por equipo.
Página 228/400
Práctica 32 Circuito Multiplexor.en PCB
OBJETIVOS:
Uso de circuito integrado 74151 Multiplexor de 8 entradas una salda y selector de
datos..
¿Qué es un Circuito Multiplexor?
Un multiplexor, abreviado como “MUX” o “MPX”, es un dispositivo, circuito lógico

combinatorio, que permite seleccionar una o más señales de entrada analógicas o
digitales de baja velocidad, combinarlas y transmitirlas a mayor velocidad en un
único medio compartido o dentro de un único dispositivo compartido. Así, varias
señales pueden compartir un único dispositivo o conductor de transmisión, como
un cable de cobre o un cable de fibra óptica. Un MUX funciona como un
conmutador de entrada múltiple y salida única.
En las telecomunicaciones, las señales combinadas, analógicas o digitales, se

consideran una señal de alta velocidad de salida única transmitida por varios
canales de comunicación mediante un método o técnica de multiplexación
particular. Con dos señales de entrada y una de salida, el dispositivo se denomina
multiplexor 2 a 1; con cuatro señales de entrada es un multiplexor 4 a 1; etc.
Los multiplexores funcionan como interruptores rotativos de posición múltiple de

acción muy rápida que conectan o controlan varias líneas de entrada llamadas
“canales”, una a una, a la salida.
Los multiplexores, o MUX, pueden ser circuitos digitales hechos de puertas lógicas
de alta velocidad usadas para conmutar datos digitales o binarios o pueden ser de
tipo analógico usando transistores, MOSFET o relés para conmutar una de las
entradas de voltaje o corriente a través de una sola salida.
Página 229/400
El tipo más básico de dispositivo multiplexor es el de un conmutador giratorio
unidireccional.
En el caso de las señales analógicas en las telecomunicaciones (y en el

procesamiento de señales), un multiplexor por división de tiempo (TDM) puede
seleccionar múltiples muestras de señales analógicas separadas y combinarlas en
una señal analógica de banda ancha con modulación de amplitud de pulso (PAM).
En el caso de las señales digitales en las telecomunicaciones en una red

informática o con vídeo digital, se pueden combinar o multiplexar varias corrientes
de datos de velocidad binaria variable de señales de entrada (utilizando la
comunicación en modo de paquetes) en una señal de ancho de banda constante.
Con un método alternativo que utiliza una MDT, se puede multiplexar un número
limitado de corrientes de datos de velocidad binaria constante de señales de
entrada en una corriente de datos de velocidad binaria más alta.
Un multiplexor requiere un demultiplexor para completar el proceso, es decir, para

separar las señales de multiplexación transportadas por el único medio o
dispositivo compartido.
A menudo un multiplexor y un demultiplexor se combinan en un solo dispositivo

(también llamado a menudo simplemente multiplexor) permitiendo que el
dispositivo procese tanto las señales entrantes como las salientes.
Alternativamente, la salida única de un multiplexor puede conectarse a la entrada
única de un demultiplexor a través de un solo canal. Cualquiera de los dos
métodos se utiliza a menudo como medida de ahorro de costes. Dado que la
mayoría de los sistemas de comunicación transmiten en ambas direcciones, se
necesitará el dispositivo único combinado, o dos dispositivos separados (en el
último ejemplo), en ambos extremos de la línea de transmisión.
Página 230/400
Tipos de Multiplexor
Multiplexación inversa (IMUX)
Multiplexación por División de Longitud de Onda (WDM)
Multiplexación por División de Longitud de Onda Densa (DWDM)
Multiplexación por División de Longitud de Onda Convencional (CWDM)
Multiplexor óptico reconfigurable Add-Drop (ROADM)
Multiplexación por División de Frecuencias (FDM)
Multiplexación por División de Frecuencia Ortogonal (OFDM)
Agregar/Dejar Multiplexación (ADM)
Conmutador de multiplexación básica
El interruptor giratorio, también llamado interruptor de oblea, ya que cada capa del
interruptor se conoce como oblea, es un dispositivo mecánico cuya entrada se
selecciona girando un eje. En otras palabras, el interruptor giratorio es un
interruptor manual que se puede utilizar para seleccionar datos individuales o
líneas de señal simplemente girando sus entradas “ON” o “OFF”. Entonces,
¿cómo podemos seleccionar cada entrada de datos automáticamente usando un
dispositivo digital.
Página 231/400
En la electrónica digital, los multiplexores también se conocen como selectores de
datos porque pueden “seleccionar” cada línea de entrada, se construyen a partir
de interruptores analógicos individuales encajados en un solo paquete de IC, a
diferencia de los selectores de tipo “mecánico” como los interruptores y relés
convencionales normales.
Se utilizan como un método para reducir el número de puertas lógicas necesarias

en un diseño de circuito o cuando se requiere una sola línea o bus de datos para
transportar dos o más señales digitales diferentes. Por ejemplo, un único
multiplexor de 8 canales.
Generalmente, la selección de cada línea de entrada en un multiplexor se controla

mediante un conjunto adicional de entradas denominadas líneas de control y
según la condición binaria de estas entradas de control, ya sea “ALTA” o “BAJA”,
la entrada de datos apropiada se conecta directamente a la salida. Normalmente,
un multiplexor tiene un número par de 2n líneas de entrada de datos y un número
de entradas de “control” que se corresponden con el número de entradas de
datos.
Nótese que los multiplexores son diferentes en su funcionamiento a los

codificadores. Los codificadores son capaces de cambiar un patrón de entrada de
n-bit a múltiples líneas de salida que representan el equivalente de salida
codificado binario (BCD) de la entrada activa.
Página 232/400
El circuito 74 151
Descripción
El SN74LS151N es un selector de datos o multiplexor de 8 a 1 línea con
decodificación binaria en el chip para seleccionar la fuente de datos deseada. El
LS151 selecciona una de las ocho fuentes de datos. Un nivel alto en la luz
estroboscópica fuerza a la salida W alta y a la salida Y (según corresponda) a
bajo. El LS151 tiene salidas W y Y complementarias. Para usar como generador
de funciones booleanas.
Selecciona una de las ocho fuentes de datos

Realiza conversión paralela a serie
Permite multiplexar desde líneas N a una línea
Los diodos de fijación de entrada simplifican el diseño del sistema
Aplicaciones: Industrial, Comunicaciones y Red
Especificaciones
Familia: LS
Tipo lógica del circuito: Selector / Multiplexor de datos
Número de canales: 1
Configuración en línea: 8:1
Tensión de alimentación mínima: 4.75 V
Tensión de alimentación máxima: : 5.25 V
Tiempo de retardo de propagación promedio: 9 ns
Disipación de energía típica 151 A: 135 mW
Temperatura de operación mínima: 0 °C
Temperatura de operación máxima: 70 °C
Encapsulado: DIP
Número de pines: 16
Página 233/400
El multiplexor es el circuito lógico combinacional equivalente a un interruptor
mecánico giratorio de varias posiciones, tal como el componente que sirve para
seleccionar las bandas de un receptor de radio.
Permite dirigir la información binaria procedente de diversas fuentes a una única

línea de salida, para ser transmitida a través de ella, a un destino común.
Disponen de: hasta 2n líneas de entrada de datos, una única de salida y n

entradas de selección; que habilitan y ponen en contacto uno de los terminales de
entrada de datos con el de salida.
El circuito combinacional integrado multiplexor, suele tener: 8 entradas de datos

(bits), 3 entradas de selección (address) y una única salida e datos.
Por ejemplo cuando en las entradas de selección está activa la combinación 010
Equivalente a la entrada de información número 2, en la salida aparecerá el bit
que en ese momento haya en la entrada 2 es decir un 1, ya que esta es la entrada
que hemos seleccionado para comunicarla con la salida.
Página 234/400
Se puede observar el conexionado en la figura siguiente , obtenida de su data
sheet, del multiplexor 74151, con las tres entradas de selección (S2, S1 y S0), las
ocho entradas de datos (I7, I6, I5, I4, I3, I2, I1 e I0), Una entrada de inhibición (δ)
una salida (Y) y otra salida más que es la negada de la anterior (ϔ)
El encapsulado de este circuito, es decir la forma comercial del circuito integrado

que lo aloja, es la de la imagen siguiente:
Página 235/400
Diagrama
MONTAJE CIRCUITO
requerido.
Página 236/400
PROCEDIMIENTO:
Fig. (2)
Página 237/400
Página 238/400
Actividad 2).-Con base a su investigación de los CI Multiplexores, explicar cómo
funciona.
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
R:
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
R:
_________________________________________________________________
_________________________________________________________________
Página 239/400
Actividad 5).-
Grado: _____________________ Grupo ___________________________
Actividad 6).-
Página 240/400
Práctica 33) Diseño de un contador binario con el circuito 7446 en
FISICO para PCB.
OBJETIVOS:
Uso del circuito integrado 7446 para contador binario.
¿Qué es un Circuito Contador Binario?
Contador binario:
Contador binario asíncrono ascendente

Por ser asíncrono, la señal de reloj (señal contada) sólo ataca al flip-flop que
contiene el LSb. Por ser binario, la secuencia de conteo es 2^n-1,0,1 donde n es el
número de flip-flops que componen el contador. El módulo de un contador binario
de este tipo es 2n (el máximo que se puede conseguir utilizando n flip-flops). Su
construcción es muy sencilla si utilizamos flip-flops JK con J=K=1 - en cuyo caso el
flip-flop se llama T -. Un contador binario de 1 bit es un flip-flop JK configurado de
esta forma. Cada vez que llega un pulso de reloj, el flip-flop bascula, lo que genera
sobre Q una secuencia de pulsos de frecuencia mitad que la frecuencia de reloj.
Esta señal puede a su vez utilizarse para disparar otro flip-flop T y a la salida de
éste tendremos una secuencia de pulsos de frecuencia (de nuevo) mitad. La figura
describe un contador asíncrono binario de 3 bits y la figura muestra las señales
obtenidas a las salidas de los flip-flops, junto con la señal de reloj contada.
Notar que, debido al tiempo de retardo asociado a cada flip-flop, el disparo de

éstos nunca se produce al mismo tiempo. Dicha circunstancia limita la máxima
frecuencia de reloj a la que pueden contar. Lo que está ocurriendo es que,
dependiendo de la frecuencia de reloj y de los retardos de propagación de los flip-
flops, puede ocurrir la circunstancia en la que, por ejemplo la condición
Q0=Q1=Q2=0 - por la que deben de pasar todos los contadores binarios - puede
Página 241/400
no llegar nunca a cumplirse. Se dice entonces que el contador es imposible de
decodificar.
Generalizando, si tpFF es el tiempo de retardo asociado a un flip-flop y n es el

número de flip-flops empleados para construir el contador asíncrono binario, la
máxima frecuencia de reloj a la que es posible operar es
Página 242/400
PROCEDIMIENTO:
Actividad 1).-. Analice el siguiente circuito de la figura (2) ármelo como se indica e
implemente en PCB. Fig. (2).
Página 243/400
Desarrollar el circuito en PCB. Como se ilustra en las figuras siguientes.
Página 244/400
Actividad 2).-Con base a su investigación de los CI Contadores, explicar cómo
funciona.
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
R:
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
_________________________________________________________________
R:
_________________________________________________________________
_________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
Página 245/400
Actividad 5).-
Grado: _____________________ Grupo ___________________________
Actividad 6).-
Página 246/400
Práctica 34) Diseño de Decodificador 7s con el circuito 7448 en
FISICO para PCB.
OBJETIVOS:
Uso de circuito integrado 7448 decodificador 7s cátodo común.
¿Qué es un Circuito Codificador y que es un Circuito Decodificador?
Codificadores:
Un codificador es un circuito combinacional con “n” entradas y “m” salidas, cuya
misión es presentar en la salida el código binario correspondiente a la entrada
activada.
Existen dos tipos fundamentales de codificadores: codificadores sin prioridad y

codificadores con prioridad.
En el caso de codificadores sin prioridad, puede darse el caso de salidas cuya
entrada no pueda ser conocida: por ejemplo, la salida 0 podría indicar que no hay
ninguna entrada activada o que se ha activado la entrada número 0. Además,
ciertas entradas pueden hacer que en la salida se presente la suma lógica de
dichas entradas, ocasionando mayor confusión. Por ello, este tipo de codificadores
es usado únicamente cuando el rango de datos de entrada está correctamente
acotado y su funcionamiento garantizado.
Dirección local de lugar.

Para evitar los problemas anteriormente comentados, se diseñan los codificadores
con prioridad. En estos sistemas, cuando existe más de una señal activa, la salida
codifica la de mayor prioridad (generalmente correspondiente al valor decimal más
alto). Adicionalmente, se codifican dos salidas más: una indica que ninguna
entrada está activa, y la otra que alguna entrada está activa.
Página 247/400
Esta medida permite discernir entre los supuestos de que el circuito estuviera
deshabilitado por la no activación de la señal de capacitación, que el circuito no
tuviera ninguna entrada activa, o que la entrada número 0 estuviera activada.
También entendemos como codificador (códec), un esquema que regula una serie
de transformaciones sobre una señal o información. Estos pueden transformar una
señal a una forma codificada usada para la transmisión o cifrado o bien obtener la
señal adecuada para la visualización o edición (no necesariamente la forma
original) a partir de la forma codificada.
En este caso, los codificadores son utilizados en archivos multimedia para

comprimir audio, imagen o vídeo, ya que la forma original de este tipo de archivos
es demasiado grande para ser procesada y transmitida por los sistemas de
comunicación disponibles actualmente. Se utilizan también en la compresión de
datos para obtener un tamaño de archivo menor.
Según esta nueva definición, podemos dividir los codificadores en códecs sin
pérdidas y códecs con pérdidas, según si la información que se recupera coincide
exactamente con la original o es una aproximación.
Decodificadores:
Tienen como función detectar la presencia de una determinada combinación de
bits en sus entradas y señalar la presencia de este código mediante un cierto nivel
de salida.
Un decodificador posee N líneas de entrada para gestionar N bits y en una de las
2N líneas de salida indica la presencia de una o mas combinaciones de n bits.
Para cualquier código dado en las entradas solo se activa una de las N posibles
salidas.
Página 248/400
PROCEDIMIENTO:
Fig. (2) e implemente en PCB.
Página 249/400
Página 250/400
Actividad 2).-Con base a su investigación de los CI Decodificadores, explicar cómo
funciona.
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
R:
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
_________________________________________________________________
R:
_________________________________________________________________
_________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
Página 251/400
Actividad 5).-
Grado: _____________________ Grupo ___________________________
Actividad 6).-
Página 252/400
Práctica 35) Diseño de un Control para motor de CD y a Pasos con el
circuito LM293 en FISICO para PCB.
OBJETIVOS:
Uso del circuito integrado LM293 para control de motor de CD y Pasos
simultáneamente.
¿Qué es un LM293 puente H de potencia?
Descripción
El circuito integrado L293D incluye en su interior 4 drivers o medio puente H. La

corriente máxima que el L293D puede manejar es de 600 mA con voltajes desde
4.5 volts a 36 volts.
Todas las entradas del circuito Integrado L293D son compatibles con TTL, por lo
que pueden manejarse con la mayoría de los micro controladores y circuitos
lógicos del mercado. La salida de los drivers puede activarse y desactivarse en
pares, mediante señales de habilitación. Cuando se presenta un 1 lógico en los
pines de habilitación, las señales correspondientes de salida estarán activas y en
fase con la señal de entrada. Cuando las entradas de habilitación presentan un
estado lógico 0, las salidas se encuentran en estado de alta impedancia.
Gracias a que este circuito integrado es capaz de producir corrientes

bidireccionales, es útil en aplicaciones que requieran controlar la dirección de giro
y velocidad de motores de DC. Otras de sus aplicaciones son el control de
relevadores, motores de paso bipolares, solenoides y cualquier otro dispositivo
electrónico de corriente continua que cumpla con las especificaciones eléctricas
del dispositivo.
Página 253/400
Características de L293D Circuito integrado puente H
Alimentación: 45 a 36 VDC
Corriente de salida: 600 mA.
Corriente pico de salida: 1 A por canal (no repetitiva).
Encapsulado: DIP de 16 pines.
Alta inmunidad al ruido eléctrico.
Protección contra exceso de temperatura.
Diodos de protección (flyback) incorporados.
Página 254/400
PROCEDIMIENTO:
Actividad 1).-. Analice el siguiente circuito de la figura (2) ármelo como se indica e
implemente en PCB. Fig. (2).Control de Motor CD
Armar la simulación siguiente: Control del Motor a Pasos
Página 255/400
Página 256/400
Actividad 2).-Con base a su investigación del CI Puente H, explicar cómo funciona.
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
R:
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
_________________________________________________________________
R:
_________________________________________________________________
_________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
Página 257/400
Actividad 5).-
Grado: _____________________ Grupo ___________________________
Actividad 6).-
Página 258/400
Practica 36).- Desarrollar un Programa que controle el encendido y
apagado de 4 relevadores vía bluetooth.
Objetivo: El alumno Desarrollará el circuito electrónico, programa para
microcontrolador y programa para Celular. Que controlen el encendido y apagado
de 4 relevadores.
Tarea 1: Investigar sobre Comunicación Bluetooth

Complemento Apuntes 1 Sobre Programación APPInventor
Lectura de Práctica y Análisis -- 1 día

Programación ---- 2 días
Armado de Circuito ---- 2 días
Entrega para firmar --- 10 min
Tiempo total max 5 días.

Actividad 2 Desarroller el Diagrama de Flujo de la figura 1.0
Actividad 6 Armar el circuito de la figura 1.1
Página 259/400
Cómo conectar Arduino con el dispositivo Android y así recibir datos de sensores,
o enviar comandos para activar un actuador ver. doomsday device.
A diferencia de lo que pueda parecer, comunicar Arduino con un sistema Android
no es difícil gracias a los módulos HC 06 o CH 05. Sobre estos módulos ver mas
al respecto,
Configurar el módulo HC 06 (cambiar el nombre y el password) y aprender a
enviar comandos del móvil a Arduino. Concretamente, encenderemos y
apagaremos el LED 13.
¿Qué vamos a necesitar?
 Móvil/tablet con Android
 Módulo Bluetooth HC 06
 Arduino UNO
 Jumpers para conectar Arduino con el módulo
 Cable USB compatible con Arduino
1- Configurar el módulo Bluetooth
Los módulos bluetooth vienen con un nombre y contraseña predefinidos de
fábrica, pero podemos cambiarlos a gusto si conectamos el módulo a Arduino y la
configuramos con este código:
/* Este programa fue publicado por Transductor en su

* tutorial de Arduino y Bluetooth :
*
* http://robologs.net/2015/05/15/tutorial-de-bluetooth-con-arduino-hc-06-en-linux/
*/
char nombre[10] = "ArduinoR"; //El nuevo nombre del modulo
char password[10] = "0000"; //El nuevo password. Seh, no es muy seguro...
char baud = '4'; //4 = 9600 baud
void setup()
{
Serial.begin(9600);
pinMode(13, OUTPUT);
digitalWrite(13, LOW);
delay(15000); //Esperar 15 segundos para conectar el modulo
Serial.print("AT"); //Iniciar la configuracion
Página 260/400
delay(1000);
Serial.print("AT+NAME"); Serial.print(nombre); //Cambiar el nombre

delay(1000);
Serial.print("AT+PIN"); Serial.print(password); //Cambiar contrasena

delay(1000);
Serial.print("AT+BAUD"); Serial.print(baud); //Cambiar baudios

delay(1000);
digitalWrite(13, HIGH);
}
void setup()
Serial.begin(9600); //Iniciar el serial
pinMode(13, OUTPUT); //Establecer el pin 13 como salida
void loop()
{
if(Serial.available()>=1)
{
char entrada = Serial.read(); //Leer un caracter
if(entrada == 'h' or entrada == 'H') //Si es 'H', encender el LED

{
Serial.println("LED encendido");
}
else if(entrada == 'l' or entrada == 'L') //Si es 'L', apagar el LED

{
Serial.println("LED apagado");
}
else if(entrada == 'i' or entrada == 'I') //Si es 'I', mostrar un mensaje de ayuda
{
Serial.println("Comandos:n (i) - abrir esta listan (h)- encender ledn (l) - apagar ledn);
Página 261/400
}
}
}
Hay que desconectar el módulo Bluetooth de la placa Arduino antes de cargar el programa.
¿La razón? El HC 06 utiliza los pines RX y TX del Serial. Si lo dejásemos conectado no se
cargaría el programa. Immediatamente después de cargar el programa, conectamos el
módulo así:
 Arduino 5V – HC06 VCC
 Arduino GND – HC06 GND
 Arduino RX – HC06 TX
 Arduino TX – HC06 RX
(tenemos 15 segundos para conectarlo)
2- Sketch de Arduino
Debemos copiar este código en la IDE de Arduino y cargarlo a la placa. ¿Qué hace? Este
programa sirve para leer carácteres por Bluetooth. Si se envía una ‘h’, encenderá el LED
13, lo apagará con ‘l’ y con ‘i’ enviará una lista con los comandos posibles. Si quieres,
puedes añadir más condicionales para encender más LEDs, controlar servos, etc.
Para poder cargar el programa a la placa el módulo Bluetooth tiene que estar desconectado.
void setup()
{
Serial.begin(9600); //Iniciar el serial
pinMode(13, OUTPUT); //Establecer el pin 13 como salida
}
void loop()
{
if(Serial.available()>=1)
{
char entrada = Serial.read(); //Leer un caracter
if(entrada == 'h' or entrada == 'H') //Si es 'H', encender el LED

{
Serial.println("LED encendido");
}
Página 262/400
else if(entrada == 'l' or entrada == 'L') //Si es 'L', apagar el LED
{
Serial.println("LED apagado");
}
else if(entrada == 'i' or entrada == 'I') //Si es 'I', mostrar un mensaje de ayuda
{
Serial.println("Comandos:n (i) - abrir esta listan (h)- encender ledn (l) - apagar ledn);
}
}
}
3- Instalar App de Android

Necesitamos una App que pueda enviar carácteres por Bluetooth a un dispositivo.
Yo lo he probado con “Bluetooth Terminal” de qwerty y me ha funcionado bien, así
que recomiendo esta aplicación. Abrimos la Google PlayStore en nuestro
dispositivo Android y la instalamos.
Ahora emparejamos el móvil con Arduino. Vamos al menú de Parámetros-
>Bluetooth->Emparejar con un dispositivo y seleccionamos el nombre que le
hemos puesto al HC 06.
¡Paciencia, ya casi estamos! Ahora abrimos el Bluetooth Terminal que hemos
descargado, y pulsamos los tres cuadraditos grises que hay arriba a la derecha.
Necesitamos decirle que conecte con Arduino, así que seleccionamos “Connect a
device – Secure” y buscamos Arduino.
Ahora podemos enviar cualquier carácter escribiéndolo en la consola.
Página 263/400
Si arduino está alimentado, veremos que el LED 13 se apaga y se enciende al
enviar ‘h’ y ‘l’.
La gracia ahora estaría en ampliar el código de Arduino para recibir más
carácteres y activar actuadores o recibir lecturas de sensores en tiempo real.
Porque encender y apagar un LED no es demasiado estimulante, la verdad.
Si tenéis cualquier duda escribidme en los comentarios, estaré encantada de
ayudar. Y si os ha servido para vuestro proyecto
Página 264/400
3- Instalar App de Android
Necesitamos una App que pueda enviar carácteres por Bluetooth a un dispositivo.
Yo lo he probado con “Bluetooth Terminal” de qwerty y me ha funcionado bien, así
que recomiendo esta aplicación. Abrimos la Google PlayStore en nuestro
dispositivo Android y la instalamos.
Ahora emparejamos el móvil con Arduino. Vamos al menú de Parámetros-
>Bluetooth->Emparejar con un dispositivo y seleccionamos el nombre que le
hemos puesto al HC 06.
¡Paciencia, ya casi estamos! Ahora abrimos el Bluetooth Terminal que hemos
descargado, y pulsamos los tres cuadraditos grises que hay arriba a la derecha.
Necesitamos decirle que conecte con Arduino, así que seleccionamos “Connect a
device – Secure” y buscamos Arduino.
Página 265/400
Ahora podemos enviar cualquier carácter escribiéndolo en la consola.
Si arduino está alimentado, veremos que el LED 13 se apaga y se enciende al

enviar ‘h’ y ‘l’.
La gracia ahora estaría en ampliar el código de Arduino para recibir más
carácteres y activar actuadores o recibir lecturas de sensores en tiempo real.
Porque encender y apagar un LED no es demasiado estimulante, la verdad.
Si tenéis cualquier duda escribidme en los comentarios, estaré encantada de
ayudar.
Página 266/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 267/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 268/400
Practica 37).- Desarrollar un Probador de sensores Analógicos y
Digitales
Objetivo: Aprender el principio físico de diferentes sensores y como probar su
funcionamiento, para determinar si son analógicos o digitales.
Tarea 2: Investigar sobre Sensores Analógicos y su programación

Complemento Apuntes 2 Sobre Sensores Digitales y su programación.


Actividad 2 Desarrollar el Diagrama de Flujo
Actividad 3 Desarrollar el código para sensor digital.
Actividad 4 Desarrollar el programa para sensor analógico
Página 269/400
Objetivo: Aprender el principio físico de diferentes sensores y como probar su
funcionamiento, para determinar si son analógicos o digitales.
Nota: El probador ya viene programado para funcionar como tester, si
requiere usar otro circuito ver anexo de programación del microblue con su
consola.
Desarrollo:
Actividad 1 Dado el Circuito (1) armarlo, explicar su funcionamiento, conexión,

entradas y salidas del mismo, usando la imagen (1) de distribución de pines.
Circuito (1) Imagen (1)
Actividad
Tomando en cuenta que una entrada analógica tiene valores infinitos y una
entrada digital solo tiene valores 0 y 1; Explicar cuando se usan entradas
analógicas y cuando se deberán usar entradas digitales en los sensores.
R: ____________________________________________________________
______________________________________________________________
______________________________________________________________
Página 270/400
Actividad 3
Las salidas del circuito se medirán con el multímetro si son digitales y con el
osciloscopio si son analógicas, observe y explique cómo se leen, el porqué de
dichas salidas en el circuito probador y hacer una tabla de salidas contra entradas.
Tabla (A) comparativa de entradas contra salidas del circuito probador.
Entrada No. Valor de entrada Valor de Salida
Analógico Digital Analógico Digital
1______ _______ _____ ______ ______
2______ _______ _____ ______ ______
3______ _______ _____ ______ ______
4______ _______ _____ ______ ______
5______ _______ _____ ______ ______
6______ _______ _____ ______ ______
7______ _______ _____ ______ ______
8______ _______ _____ ______ ______
9______ _______ _____ ______ ______
10_____ _______ _____ ______ ______
Página 271/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 272/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 273/400
Practica 38).- Desarrollar un programa de control de motor de CD,
CA, MOT a Pasos y Servo Motor. Controlar CON POTENCIÓMETRO
DIGITAL
Objetivo: Aprender el principio de funcionamiento de los motores CD, CA, Mot a
Pasos y Servo Motor.
Tarea 3: Investigar sobre Motores de CD y CA asi como su control por digital

Complemento Apuntes 3 Sobre Motor a Pasos y Motor Servo y su control digital.


Actividad 2 Desarrollar el diagrama de Flujo
Actividad 3 Desarrollar el código mot CD.
Actividad 4 Desarrollar el programa mot a pasos
Página 274/400
Ejemplo de un control de motor de CD, buscar los demás controles
Control de motores con Arduino. Específicamente motores de corriente contínua

estándar. Existen algunos motores DC especiales como los motores paso a paso
o sin escobillas (brushless en inglés) que no serán tratados aquí. Una buena parte
de la información servirá para otras plataformas como Raspberry Pi, pero en
general las librerías de programación y los esquemas estarán dedicados en
exclusiva a Arduino.
Arduino tiene pines de entrada y de salida para comunicarse físicamente con su
entorno. Los pines de salida pueden dar una pequeña cantidad de energía que
sirve por ejemplo para encender un LED, pero no pueden alimentar a un motor.
Para ello necesitamos un circuito que haga de intermediario. Este circuito, el
controlador o driver de motores, tomará energía de otra fuente (una pila, batería o
equivalente) y siguiendo las instrucciones de Arduino hará funcionar el motor.
Existen muchos drivers diferentes, pero para poder controlar bien un motor
necesitamos dos características fundamentales:
 Que permitan invertir el sentido de giro del motor.
 Que permitan graduar la velocidad de giro del motor.
Página 275/400
Drivers con Puentes H
El circuito básico que permite las dos funciones que dijimos es un puente H. Un
motor DC cambia el sentido de giro cuado invertimos los polos positivo y negativo
en sus bornes, y este circuito juega con una serie de interruptores para hacer ese
cambio de polaridad. Podemos construir un puente H con cuatro interruptores,
pero lo que usaremos es un circuito integrado que tiene esos interruptores -o
puertas- y las abrirá y cerrará siguiendo instrucciones del Arduino.
Señales PWM
Un motor DC está preparado para funcionar a una tensión que nos dará el
fabricante. Si le damos una tensión menor girará más despacio, llegando en el
extremo a pararse. Así regulamos la velocidad.
Arduino no puede (con excepciones) regular directamente los voltios que salen por
un pin, pero puede hacer una pequeña 'trampa' que se llama PWM y que tiene
como resultado una acción parecida a bajar la tensión. En la wikipedia puede
verse una explicación de su funcionamiento, pero eso excede nuestro objetivo
aquí. Lo importante y que nos interesa ahora es:
 Arduino puede generar señales PWM y así simular una tensión menor en
voltios.
 Esta señal sirve para controlar motores a través de un puente H (¡¡¡con una
señal 'verdadera' no se puede!!!).
 Los motores DC aceptan esta señal 'falsa' y podemos ajustar así la
velocidad.
Página 276/400
No todos los pines de Arduino pueden hacer esta función PWM. En los diagramas
de funcionamiento de cada modelo puede verse cuáles la tienen y cuáles no.
Librerías de programación
La programación de Arduino, igual que muchos lenguajes, permite la creación de
nuevas instrucciones en forma de librerías.
Para utilizar un driver combinaremos salidas PWM con salidas digitales en las que
las opciones son apagado (LOW) o apagado (HIGH). Cada driver tiene su tabla
lógica para funcionar. Un ejemplo de código para mover un motor podría ser este:
analogWrite(9, 200);
Sin embargo en lugar trabajar con los pines uno a uno, lo haremos indirectamente
con librerías que transformarán ese código en algo más sencillo como
'robot.adelante'. Están pensadas para robots de dos ruedas (o cuatro, pero
funcionando dos a dos) y darle instrucciones sencillas del tipo: avanza, retrocede,
gira, frena.
nombredelrobot.forward(128,128,1000);
nombredelrobot.reverse(128,128,1000);
nombredelrobot.rotate(128,128,1000);
nombredelrobot.rotate(128,128,-1000);
nombredelrobot.brake(1000);
Hemos tratado de que las librerías tengan todas las mismas instrucciones con
independencia del driver. Están alojadas en Github y también allí están los detalles
para su uso. Como todo el material de Bricolabs son libres, puedes hacer con ellas
lo que quieras.
Página 277/400
Conexionado general
Un driver de motores, tal y como se puede ver en el diagrama de bloques de
arriba, tendrá una serie de cables que van al Arduino (líneas de control), una
entrada de energía conectada a una fuente como una batería o similar (línea de
potencia) y las líneas que van finalmente a los motores.
Características generales de los drivers

Cuando elegimos un driver para nuestro proyecto -de robot móvil o lo que
queramos- debemos tener en cuenta varias cosas:
 Cuántos motores vamos a controlar. Hay circuitos integrados -y placas- que
pueden controlar 1, 2, 4, 6 o el número que se nos ocurra.
 Qué potencia (consumo en mA) necesitan esos motores. El driver deberá
dara esa potencia o más.
 Qué tensión de alimentación (en V) tienen los motores.
Si la potencia es suficiente podremos conectar dos motores en paralelo a una
misma salida de un driver. También podemos conectar varios drivers (iguales o
no) pero necesitaremos un Arduino con muchas salidas (como el Mega 2560) o un
circuito más especializado con otro tipo de comunicación.
Además tendremos en cuenta, en función de nuestro proyecto, el tamaño del
driver. Para proyectos en miniatura como Sapoconcho elegimos un driver muy
pequeño.
Página 278/400
Drivers más utilizados en proyectos DIY/DIWO
A continuación vamos a detallar una lista de drivers utilizados muy comunmente
en proyectos de robótica casera, que conocemos de nuestros propios proyectos y
para los que hemos creado librerías. La lista incluye:
 L9110
 L298N
 L297D
 TB6612FNG
 DRV8835
Si el motor una vez conectado no gira en el sentido deseado podemos cambiarlo
muy fácilmente tanto en el hardware (intermabiando los cables del motor o del
driver) como en el software (cambiando los pines en la programación).
L9110
Este pequeño driver (y su gemelo HG7881) sirve para controlar motores de entre
2.5 y 12 voltios y con un consumo máximo de 800 mA. El integrado sirve para
controlar sólo un motor, pero habitualmente se monta en placas con dos unidades
para controlar dos motores. Es el que utilizamos para los motores de tipo N20 del
Sapoconcho.
Página 279/400
La típica placa doble tiene cuatro fichas para atornillar los cables de los motores y
seis pines:
 Dos de control PWM para el motor A (A-IA, A-IB).
 Dos para el motor B (idem, B-IA, B-IB).
 Dos de alimentación desde las pilas o baterías (VCC, GND).
La conexión ya la hemos visto para un Arduino Pro Micro. Para un cualquier otro
es similar, buscando siempre 4 pines PWM.
La lógica de operación de la placa para cada uno de los motores es la siguiente (la
tabla indica la señal en cada pin para el motor A).
Giro adelante Giro atrás Parada

Pin
AI-A pwm 0 0
AI-B 0 pwm 0
Página 280/400
Librerías de funcionaminto para L9110: en este enlace de Github puedes
descargar los archivos L9110.cpp y L9110.h. Deberás instalarlos en la carpeta de
librerías de Arduino. En ese mismo enlace puedes descargar varios ejemplos de
programas para tu robot y ver la sintaxis para llamar a las funciones de
movimiento.
Una vez conectado el driver e instaladas las librerías deberás elegir un nombre
para tu robot, y decirle en qué pines has conectado el driver (en el ejemplo los
pines 3, 5, 6 y 9), y para eso comenzar tus programas de este modo:
#include <L9110.h>
L9110
A continuación ya puedes usar dentro de tu código las funciones de movimiento de
la librería para moverte adelante, atras, girar y frenar.
Página 281/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 282/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 283/400
Practica 39).- Armado y prueba de chasis del circuito giratorio de
led´s.
Objetivo: Arme el prototipo de un arreglo giratorio de led´s y el circuito de control
de velocidad anterior, y desarróllelo físicamente use 5 led´s RGB. Vea ejemplos.
Tarea 5 Investigar sobre Control de leds Giratorios.
Actividad 1
Armar el circuito de control de velocidad y control de led:
Actividad 2
Plantear una hipótesis del funcionamiento de su circuito para solucionar la
problemática requerida.
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
Actividad 3
Página 284/400
Desarrollar el prototipo solicitado que presente la solución al problema con base al
funcionamiento del circuito empleando y sensor requerido. Vea aquí unos
ejemplos de cómo puede quedar su trabajo.
Página 285/400
Ejemplo de circuito propuesto.
Página 286/400
Actividad 4
Describir el funcionamiento del circuito que soluciona la problemática.
R:
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
Actividad 5
Anotar conclusiones y recomendaciones.
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
Página 287/400
Actividad 6
Prueba y programa demo del circuito giratorio de led´s.

Desarrollar un programa para microcontrolador que prenda de manera

ALEATORIA LOS LEDS.
Desarrolle una tabla donde dibuje la forma en que prenderán los led´s en un rango
máximo y mínimo en la escala de tiempo marcada por las RPM del controlador de
velocidad.
Ejemplo de su tabla de rangos, supongamos una velocidad de 1200 RPM
Página 288/400
Ejemplo de Instrucciones a emplear en el programa
Página 289/400
Actividad 7
Plantear una hipótesis del funcionamiento de su programa para solucionar la
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
Actividad 8

funcionamiento del circuito empleando y sensor requerido. Vea aquí unos
ejemplos de cómo puede quedar su trabajo.
Página 290/400
Actividad 9
Describir el funcionamiento del programa que soluciona la problemática.
R:
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
Actividad 10
Anotar conclusiones y recomendaciones. Anexar código fuente de programación
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
R:
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
Página 291/400
Actividad 11
Anexar código fuente de programación y Mostrar el funcionamiento de su trabajo

al profesor, si tienen dudas preguntar, pues le deberá quedar completamente claro
el funcionamiento de su circuito.
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 292/400
Grado: _____________________ Grupo ____________________________
Actividad 12
Tarea 5.2 Investigar sobre programación de pic y tarjetas entrenadoras de

circuitos electrónicos.

Página 293/400
Practica 40).- Desarrollar un Vehículo que se estacione solo
evadiendo obstáculos.
Objetivo: Que el vehículo móvil sea capaz de cambiar su dirección con base en los
obstáculos que se encuentre.
Tiempo para desarrollo la Practica
Lectura de Práctica y Análisis -- 15 min

Programación ---- 1 horas
Armado de Circuito ---- 1 horas
Tiempo total min 5 días.

Actividad 2 Desarrollar el diagrama de Flujo de la figura
Actividad 3 Ver códigos similares.
Actividad 4 Desarrollar el programa.
Actividad 6 Armar el circuito
Página 294/400
Actividad 9) Analizar la solución tomando en cuenta la figura siguiente
Analizar geometría, ángulos, propiedades de líneas paralelas
Página 295/400
Actividad 10
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 296/400
Grado: _____________________ Grupo ____________________________
Actividad 11

Página 297/400
Practica 41).- Receptor de Control Remoto de TV para prender un
ventilador y controlar su velocidad.
Objetivo General: El alumno aprenderá la comunicación IR entre arduino y Control
Remoto de TV para aplicación electrónica.
Problemática: Prender, apagar y controlar velocidad de un Ventilador de
forma remota por IR mandando de un Control Remoto de TV a su arduino,
esto se logra mediante un sensor de luz IR que detecte el Codigo
Transmitido.
Desarrollo:
Vea este ejemplo que usa un módulo sensor infrarrojo para recibir la señal de
controles remotos IR que usan muchos de los equipos domésticos como TVs,
equipos de sonidos, etc. A través de estos controlaremos las salidas de nuestro
Arduino. Usted haga el Propio.
Para este tutorial usaremos el siguiente sensor de Infrarrojos:
Este sensor tiene un filtro interno para detectar solo frecuencias

infrarrojos cercanas a 38KHz, lo que lo hace compatible con la mayoría de
mandos infrarrojos, posee 3 pines de conexión GND, VCC y DATA , el cual nos
permite conectar directamente a un pin digital de nuestro Arduino o cualquier
microcontrolador que deseemos usar.
Como mando usaremos uno que viene junto al sensor en el kit del mando
infrarrojo
Página 298/400
Este Mando usa el protocolo NEC que trabaja a 38KHz de frecuencia, el formato
del tren de pulsos que envía al presionar una tecla se muestra en la siguiente
gráfica:
Lo particular de este protocolo es que envía doble vez tanto la dirección como el
comando, de forma normal y negado, con esto posteriormente se puede validar los
datos.
La dirección está asociada a un dispositivo, por ejemplo un TV, una equipo de
sonido, un VCR, etc. Y el comando está asociado a la acción o función del botón.
Por ejemplo subir el volumen, apagar, el número 1 o 2, etc.
Para este tutorial vamos a trabajar como si se tratase de un solo bloque de datos
32 bits.
A continuación se muestra los valores de los datos correspondientes a los botones
del control en mención:
Página 299/400
Como se observa el dato está formado por la dirección, comando y sus
negaciones, por ejemplo para la tecla OK: el dato de 32bits es 0x00FF02FD,
donde la dirección es 00 y su negación FF, y el comando o función es 02 y su
negación FD.
Control Remoto de TV
En este tutorial también se realizarán ejemplos usando mandos de TV, en
particular usaremos un control remoto de un TV SONY
EL protocolo SONY trabaja con una frecuencia de 40KHz, en la siguiente figura se
muestra los pulsos que se envían cuando se presiona una botón
Trabaja con 12 bits de datos, de los cuales 5bits son para la direccion y 7 bits para
comando o función. Existen variaciones de 15 bits y 20 bit pero en todos los bits
de comando son de 7 bits.
A continuación se muestra algunos de los datos correspondientes al protocolo
SONY
Página 300/400
Para convertir el dato de 12 bits en su dirección y comando se toma empezando
desde el bit menos significativo considerándolo de mayor peso.
Explicado lo anterior Implementemos ambos controles en Arduino.
Librería IR remote para Arduino

IRremote es una de las librerías más usadas y completas para trabajar con
protocolos de controles infrarrojos, tiene implementado varios protocolos de las
marcas más conocidas como Sony, LG, Samsung, Sanyo, etc
Pueden descargarlo y encontrar más información en:
https://github.com/z3t0/Arduino-IRremote
Es necesario descargar e importarla a nuestro IDE Arduino para poder trabajar los
ejemplos de este tutorial
Conexiones entre Arduino y modulo receptor IR

Las conexiones son simples el sensor tiene un pin VCC el cual se alimenta con 5V
un pin GND y un pin de DATA, que es una salida digital el cual conectaremos al
pin 11 del Arduino
Página 301/400
Encendiendo un led con nuestro control Remoto.
En este ejemplo se encenderá y apagará el led del pin 13 con cualquier tecla de
nuestro control remoto, incluso con cualquier control.
El código es el siguiente:
#include <IRremote.h>
int RECV_PIN = 11;

IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
irrecv.enableIRIn(); // Empezamos la recepción por IR
pinMode(13, OUTPUT);
}
boolean on = LOW;
void loop() {
if (irrecv.decode(&results)) {
// Dato recibido, conmutamos el LED
on = !on;
digitalWrite(13, on? HIGH : LOW);
irrecv.resume(); // empezamos una nueva recepción
}
delay(300);
}
Expliquemos un poco el código:

Con IRrecv irrecv(RECV_PIN) creamos la variable u objeto para el receptor IR, en
el pin especificado, luego creamos la variable result, que es una estructura en
donde se guardaran todos los datos relacionados cuando se recibe un dato por
sensor. En Setup() inicializamos la recepción de datos con irrecv.enableIRIn() y
configuramos el pin 13 como salida.
En el void loop() simplemente comprobamos si le llega un dato al receptor, esto lo
hacemos con if(irrecv.decode(&results)), si hay un dato, encendemos o apagamos
el LED.
Después de cargar el programa, al presionar cualquier tecla de cualquier control
remoto, deberá encender o apagar el LED.
Página 302/400
Decodificando datos de los controles infrarrojos.
En este ejemplo obtendremos los datos correspondientes a las teclas de los
diferentes mandos infrarrojos.
El código es el siguiente:
#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn(); // Empezamos la recepción por IR
}
void dump(decode_results *results) {

// Dumps out the decode_results structure.
// Call this after IRrecv::decode()
Serial.print("(");
Serial.print(results->bits, DEC);
Serial.print(" bits)");
if (results->decode_type == UNKNOWN) {
Serial.print("Unknown encoding: ");
}
else if (results->decode_type == NEC) {
Serial.print("Decoded NEC: ");
}
else if (results->decode_type == SONY) {
Serial.print("Decoded SONY: ");
}
else if (results->decode_type == RC5) {
Serial.print("Decoded RC5: ");
}
else if (results->decode_type == RC6) {
Serial.print("Decoded RC6: ");
}
else if (results->decode_type == PANASONIC) {
Serial.print("Decoded PANASONIC - Address: ");
Serial.print(results->address, HEX);
Serial.print(" Value: ");
}
else if (results->decode_type == LG) {
Serial.print("Decoded LG ");
Página 303/400
}
else if (results->decode_type == JVC) {
Serial.print("Decoded JVC ");
}
else if (results->decode_type == AIWA_RC_T501) {
Serial.print("Decoded AIWA RC T501 ");
}
else if (results->decode_type == WHYNTER) {
Serial.print("Decoded Whynter ");
}
Serial.print(results->value, HEX);
Serial.print(" (HEX) , ");
Serial.print(results->value, BIN);
Serial.println(" (BIN)");
void loop() {
if (irrecv.decode(&results)) {
dump(&results);
irrecv.resume(); // empezamos una nueva recepción
}
delay(300);
}
El código anterior envía por el puerto serial los datos correspondientes a la tecla
presionada.
A continuación se muestra los datos recibidos al presionar las teclas del control
remoto que viene con el kit del sensor.
Página 304/400
Y si utilizamos el control remoto de SONY les debe mostrar valores similares al de
la siguiente imagen:
Con este programa podemos averiguar el valor del dato correspondiente a la tecla
presionada, el mismo programa funciona para otras marcas de control remoto.
Controlar Pines digitales con control remoto por infrarrojos
Ahora que ya sabemos el valor del dato que corresponde a cada tecla, vamos a
asociar una tecla a un pin digital y prender o pagar leds, que se podrían remplazar
por cualquier otro actuador.
Para este ejemplo vamos a hacer las siguientes conexiones:
Página 305/400
Implementemos el siguiente sketch:
#include "IRremote.h"
int receiver = 11;
IRrecv irrecv(receiver);
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn();
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
}
void loop()
{
if (irrecv.decode(&results))
{
switch(results.value)
{
case 0x00FF629D: Serial.println("Tecla: Arriba");
break;
case 0x00FF22DD: Serial.println("Tecla: Izquierda");
break;
case 0x00FF02FD: Serial.println("Tecla: OK");
break;
case 0x00FFC23D: Serial.println("Tecla: Derecha");
break;
case 0x00FFA857: Serial.println("Tecla: Abajo");
break;
case 0x00FF6897: Serial.println("Tecla: 1");
break;
case 0x00FF9867: Serial.println("Tecla: 2");
break;
case 0x0FFB04F: Serial.println("Tecla: 3");
break;
case 0x00FF30CF: Serial.println("Tecla: 4");
digitalWrite(4, !digitalRead(4));
break;
case 0x00FF18E7: Serial.println("Tecla: 5");
break;
case 0x00FF7A85: Serial.println("Tecla: 6");
break;
case 0x00FF10EF: Serial.println("Tecla: 7");
break;
case 0x00FF38C7: Serial.println("Tecla: 8");
break;
Página 306/400
case 0x00FF5AA5: Serial.println("Tecla: 9");
break;
case 0x00FF42BD: Serial.println("Tecla: *");
break;
case 0x00FF4AB5: Serial.println("Tecla: 0");
break;
case 0x00FF52AD: Serial.println("Tecla: #");
break;
}
irrecv.resume();
}
delay(300);
}
Como se observa en el código solo comparamos el dato recibido del mando con
los valores correspondientes a las teclas, si coinciden con el valor de la tecla, se
realiza la acción correspondiente en el switch(), solo implementamos las teclas del
4 al 7 con leds, pero enviamos por el puerto serial una confirmación de cada tecla
presionada.
A continuación se muestra el monitor serial después de presionar algunas teclas
Página 307/400
De igual manera se trabaja con el control remoto de SONY:
#include "IRremote.h"
int receiver = 11;
IRrecv irrecv(receiver);
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn();
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
}
void loop()
{
if (irrecv.decode(&results))
{
switch(results.value)
{
case 0xA90: Serial.println("Tecla: Power");
break;
case 0x070: Serial.println("Tecla: Menu");
break;
case 0x2F0: Serial.println("Tecla: Arriba");
break;
case 0x2D0: Serial.println("Tecla: Izquierda");
break;
case 0xCD0: Serial.println("Tecla: Derecha");
break;
case 0xAF0: Serial.println("Tecla: Abajo");
break;
case 0x010: Serial.println("Tecla: 1");
break;
case 0x810 : Serial.println("Tecla: 2");
break;
break;
case 0xC10: Serial.println("Tecla: 4");
break;
break;
case 0xA10: Serial.println("Tecla: 6");
break;
break;
Página 308/400
case 0xE10: Serial.println("Tecla: 8");
break;
break;
break;
case 0x490: Serial.println("Tecla: Vol+");
break;
case 0xC90: Serial.println("Tecla: Vol-");
break;
}
irrecv.resume();
}
delay(300);
}
Página 309/400
Actividades:
1- Desarrollar el Diagrama de Flujo.
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 310/400
2- Desarrollar el código fuente de programación propio.
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
3- Al momento de la revisión se le indicara un comando X y usted deberá

programarlo antes de hacerlo físicamente y comprobarlo para ser aceptada
su práctica.
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 311/400
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Grado: _____________________ Grupo ____________________________
Tarea 11 Investigar Receptor IR en arduino
Actividad 6

Página 312/400
Practica 42).- Emisor de Control Remoto de TV para prender un TV,
cambiar canal y variar volumen con Arduino.
Objetivo General: El alumno aprenderá la comunicación IR entre arduino y Control
Remoto receptor de TV para aplicación electrónica.
Problemática: Prender, apagar y controlar volumen canales de una TV de
forma remota por IR mandando de un arduino, esto se logra mediante un
sensor y emisor de luz IR que detecte el Codigo y lo Transmita.
Desarrollo:
Vea este ejemplo pues primero debemos leer el código de control remoto de TV,
vamos a recibir e interpretar el código que se envía a través del infrarrojo por el
control:
Emplearemos primero para leer el código
1 Tarjeta Arduino (Uno, Nano o Mega)
1 Modulo receptor Infrarrojo
1 Control Remoto IR
1 Led
Página 313/400
La conexión es realmente muy sencilla. De esta conexión, usaremos el led hasta
el segundo ejemplo, el modulo receptor ya trae indicado sus pines S de “signal” y
– para GND por lo que el del medio es vcc(5v) y no hay donde perderse, si el led
es de 5v puedes usarlo sin resistencia.
Primera parte
En la primera parte lo que tenemos que hacer es recibir el código que envía
nuestro control remoto, ya que cada control remoto tiene su propia encriptación y
cada botón su propio código, luego convertirlo a hexadecimal, para poder
almacenarlo, y posteriormente utilizarlo en el segundo ejemplo, para utilizar el
emisor y receptor infrarrojo vamos a necesitar una librería llamada IRremote.
Ya anteriormente aprendimos como importar una librería. Por lo que pasaremos
de una vez al código.
Página 314/400
Lo primero que debemos hacer es insertar la librea para que podamos usar las
funciones especiales de esta.
Declaramos el pin donde ira conectado el receptor en este caso el pin 11,
Luego declaramos el nombre del receptor 11. Y también declaramos el resultado
que recibirá de la lectura del IR quien envía un TRUE cuando recibe una señal y
un FALSE cuando no recibe nada, y en caso que recibe algo lo almacena en este
caso en la variable Código, a la cual podemos llamar luego.
Lo siguiente es declarar la comunicación serial a la velocidad de 9600, podemos
usar otras entre los estándares como 115200, pero usaremos la que comúnmente
se utiliza, y también vamos a declarar que utilizaremos una receptor y no un
transmisor, por lo que ponemos irrecv.enableIRIIn()
Por ultimo ponemos vamos programar la tarea que ejecutara este código.
Utilizamos una condición If la lectura del sensor es TRUE entonces que imprima
un “0x” para completar el hexadecimal y seguidamente que imprima el valor del
código, y lo convierta a hexadecimal y que luego de leer se reiniciara para poder
capturar un nuevo valor.
Luego de esto, vamos a subir el código al Arduino y usaremos un control remoto,
presionaremos los botones y recibiremos datos en el monitor serial cada botón
envía un código diferente, vamos a guardar el código de los botones 1, 2 y Power
los guardamos en un archivo de texto. Para luego utilizarlos.
Ahora que ya tenemos el código de cada uno de los botones guardados, los
podemos utilizar para decirle al arduino “cuando recibas X botón entonces
enciende lo requerido.
Página 315/400
Segunda Parte. Vamos a poder encender la televisión enviándole el mismo código
que el control remoto le envía a través del control, nosotros lo haremos mediante
el emisor infrarrojo empleando.
1 Arduino uno
1 Protoboard
1 Pulsador
1 emisor infrarrojo ky-005
1 Resistencia de 10k
1 TV
3 Cables macho-hembra.
Los sensores infrarrojos son muy cotidianos en nuestra vida hoy en dia, los vemos
en muchos aparatos electrónicos como televisiones, DVD’s y muchos otros.
Armemos el siguiente circuito:
Página 316/400
La conexión sigue siendo muy sencilla, solo agregamos un pulsador, que lo
aprendimos a usar en el segundo tutorial, podemos usar cables macho-hembra
para extender el led infrarrojo y poder apuntarlo a la tv.
Implementar el código siguiente y probar
Página 317/400
Nuevamente vamos a incluir la librería, y ahora declaramos como emisor al IR
preparándolo para enviar mensajes, declaramos el pin del pulsador, y creamos la
variable del pulsador, luego configuramos al pulsador como entrada y agregamos
el monitor serial para observar cuando este activo el botón, luego en el void loop,
almacenamos la lectura del botón en la variable valor_button ,y agregamos
condiciones, “si el botón está presionado entonces enviar el mensaje
“0x20DF10EF,32” esto le envía el código del botón encendido que lo capturamos
en la práctica anterior, y el tamaño que es de 32 bits. Agregamos un imprimir para
el botón y con esto, ya podemos encender la tv.
Siguiendo este ejemplo usted haga que controle el cambio de canal, hacia arriba y
hacia abajo, así como el volumen de su TV.
Página 318/400
Actividades:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 319/400
2- Desarrollar el código fuente de programación propio.
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
3- Al momento de la revisión se le indicara un comando X y usted deberá

programarlo antes de hacerlo físicamente y comprobarlo para ser aceptada
su práctica.
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 320/400
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Grado: _____________________ Grupo ____________________________
Tarea 12 Investigar Emisor IR con arduino.
Actividad 6

Página 321/400
EXAMEN UNIDAD 2).- Desarrollo y Simulación Tarjeta Microchip y
Proteus
Objetivo: Desarrollar una placa entrenadora, probar con un simulador, y
posteriormente impemente su circuito físicamente, Hacer sus anotaciones
correspondientes.
NOTA: Ver Archivo anexo de Power Point de MicroControladores.
Tarea 1: Investigar sobre Programa de Simulación Proteus y Pic’s

Complemento Apuntes 1 Métodos de Instalación de Software

Armado de Circuito en Simución ----10 min
Actividad 1 Verificar contar con su simulador ya instalado.

Actividad 4 Cargar el programa *.HEX ejemplo mostrado (PIDALO AL PROFESOR
Actividad 5 Compilar el programa verificar que no tenga errores
Actividad 6 Armar el circuito de la figura en Proteus
Actividad 7 Descarga el Programa a su SIMULADOR correspondiente.
asi modifique hasta que dé el correcto.
Página 322/400
ANTES
Prgrama Programa para programar el Pic
Prgramador
Programa para bajar el programa al el Pic
Página 323/400
Diseño de PCB para pic
Página 324/400
AHORA
Programar y bajar al pic
Simular pic
Armar circuito
Página 325/400
Desarrollo: 1.PRG1-Prender 4 Leds del puerto B del pic 16f84. –PRG 2 Led que
parpadea. – PRG 3 Condicional IF. – PRG 4 Hacer el encendido de 4 rutinas diferentes
de leds. PRG 5 – Contador Binario
Se trata de realizar un ejercicio básico que consiste en encender 4 leds que
conectamos en el puerto B del pic 16f84 que se configura como salida.
INICIO EJECUCION DE PROCESOS

DEL PRGRAMA
Prender Led
DECLARANDO PUERTO Y
VARIABLES
NO
ASIGNANADO VALOR A SI
SALIDAS Y ENTRADAS DE ¿Se pulso el
LOS PUERTOS Esperando Boton?
Dato de Entada
Esquema de conexionado con PIC aplica para los 5 programas.
Página 326/400
PROGRAMA 1
'****************************************************************
'* Date : 05/11/2008 *
'* Version : 1.0 *
'* Notes : *
'* : *
'****************************************************************
'
' para pic 16f628A
' cmcon = 7
end
Página 327/400
PROGRAMA 2
'****************************************************************
'* Date : 05/11/2008 *
'* Version : 1.0 *
'* Notes : *
'* : *
'****************************************************************
'
' para pic 16f628A
'cmcon = 7
LED VAR PORTB.0 'DEFINE RB0 AS LED
LED1 VAR PORTB.1
LED2 VAR PORTB.2
LED3 VAR PORTB.3
'
'START OF MAIN PROGAM
'
TRISB=0 ' SET PORTB PINS AS OUTPUTS
AGAIN: ' ETIQUETA
LED = 1 ' PONE LED A 1
LED1 = 0
LED2 = 0
LED3 = 0
PAUSE 1000 ' ESPERA UN SEGUNDO PRENDIDO
LED = 0 ' PONE LED A CERO
PAUSE 1000 ' ESPERA UN SEGUNDO
GOTO AGAIN ' SALTA A ETIQUETA AGAIN
END
' trisb=0 'poner puerto b como salida

' repite:
' portb=1 'encender el led conectado a puerto B0
' pause 1000 ' pausa por 1 segundo 1000ms
' portb=0 ' pone a cero el led del puerto B0
' goto repite ' repite l ciclo infinito
'end
Página 328/400
PROGRAMA 3
'****************************************************************
'* Date : 05/11/2008 *
'* Version : 1.0 *
'* Notes : *
'* : *
'****************************************************************
'
' para pic 16f628A
'cmcon = 7
TRISA=%11111111
TRISB=0
repite:
IF PORTA.0=1 THEN
HIGH 0
ELSE
LOW 0
ENDIF
IF PORTA.1=1 THEN
HIGH 1
ELSE
LOW 1
ENDIF
IF PORTA.2=1 THEN
HIGH 2
ELSE
LOW 2
ENDIF
IF PORTA.3=1 THEN
HIGH 3
ELSE
LOW 3
ENDIF
goto repite
END
Página 329/400
PROGRAMA 4
'****************************************************************
'* Date : 05/11/2008 *
'* Version : 1.0 *
'* Notes : *
'* : *
'****************************************************************
'
' para pic 16f628A
'cmcon = 7
TRISA=%11111111
TRISB=0
repite:
IF PORTA.0=1 THEN
'pause 10
HIGH 0
high 2
high 4
HIGH 6
ELSE
'LOW 0
'LOW 2
'LOW 4
ENDIF
IF PORTA.1=1 THEN
HIGH 1
HIGH 3
HIGH 5
HIGH 7
ELSE
'LOW 1
'LOW 3
'LOW 5
ENDIF
IF PORTA.2=1 THEN
Página 330/400
HIGH 4
ELSE
'LOW 4
ENDIF
IF PORTA.3=1 THEN
HIGH 0
HIGH 1
HIGH 2
HIGH 3
HIGH 4
HIGH 5
HIGH 6
HIGH 7
ELSE
'LOW 0
'LOW 1
'LOW 2
'LOW 3
'LOW 4
'LOW 5
ENDIF
pause 50
LOW 0
LOW 1
LOW 2
LOW 3
LOW 4
LOW 5
LOW 6
LOW 7
goto repite
END
Página 331/400
PROGRAMA 5
'****************************************************************
'* Date : 05/11/2008 *
'* Version : 1.0 *
'* Notes : *
'* : *
'****************************************************************
' CONTADOR BINARIO DE 8 BIT´S
' para pic 16f628A
' CONTADOR DIGITAL
'cmcon = 7
' TRISA=%11111111
' TRISB=0
DEFINE OSC 12
X VAR BYTE
CNT VAR BYTE
TRISB=0
CNT=%00000000
REPITE:
FOR X=1 TO 255
PORTB=CNT
PAUSE 550
CNT =CNT +1
NEXT X
GOTO REPITE
END
Página 332/400
Desarrollar su placa PCB pic 16f84 y PCB pic 16f877. Para entregar en físico. Y
probar los programas que aquí se les dán.
Placa pic 16f84
Página 333/400
Página 334/400
PCB Pic 16877
Página 335/400
Página 336/400
Actividad 9 Descargar su archivo *.hex correspondiente a la práctica y Mostrar el
funcionamiento de su trabajo al profesor, si tienen dudas preguntar, pues le
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 337/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 338/400
Practica 43).- Desarrollar un programa que controle un módulo de 4
matrices led.
Objetivo: Desarrollar un programa que controle una módulo de 4 matrices led. Y
muestre el msg CBTIS 47 Mecatronica 2019 y una persona caminando.
Tarea 4: Investigar sobre Control de matriz led

Complemento Apuntes 4 Sobre Programación de matrices led


Actividad 2 Desarrollar el Diagrama de Flujo
Página 339/400
Componentes necesarios para el proyecto
Para el desarrollo de este tutorial necesitaremos los siguientes componentes:
 1x Arduino
 2x Matriz LED de 8×8 MAX7219
 10x Cables para protoboard
Diagrama eléctrico
La conexión de los módulos es extremadamente sencilla y se realiza a través de

un puerto serie asíncrono SPI, los pines están marcados en la placa. El pin VCC y
GND son los cables de alimentación y van conectados al directamente al Arduino
a los pines 5V y GND respectivamente. El pin DIN del módulo va conectado al pin
8 del Arduino, el pin CLK va al pin 10 y el pin CS va al pin 9 del Arduino.
Para conectar más módulos usamos la salida que hay en la parte superior de cada
módulo para conectar con la entrada del otro módulo, para mas detalle ver la
imagen del esquema.
Página 340/400
Para comunicarnos con el módulo usaremos la librería MaxMatrix.h, la
descargamos usando el enlace que hay a continuación y la descomprimimos en la
carpeta Libraries de nuestra instalación del IDE de Arduino.
Lo primero que hacemos es declarar todos los caracteres posibles (A-Z y 0-9)
como valores binarios y, en vez de declararlos como variables y colapsar la
SRAM, lo que haremos es poner esos datos en la memoria flash (memoria de
programa) usando el modificador de variable PROGMEM ya que son datos fijos
que no van a variar. A continuación tenéis el sketch que esta comentado para que
sea muy fácil de entender.
// PARA PODER USAR EL MODIFICADOR DE VARIABLE PROGMEM

#include <MaxMatrix.h>
#include <avr/pgmspace.h>
// DEFINIMOS TODOS LOS CARACTERES POSIBLES EN UN ARRAY

// Y LO CARGAMOS EN LA MEMORIA DE PROGRAMA CON PROGMEM
PROGMEM const unsigned char CH[] = {
3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // espacio
1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
Página 341/400
2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
Página 342/400
4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \
2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // sombrero
4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
Página 343/400
4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
};
// DEFINIMOS LOS PINES DEL ARDUINO
int data = 8; // Pin DIN del módulo MAX7219
int load = 9; // Pin CS del módulo MAX7219
int clock = 10; // Pin CLK del módulo MAX7219
// CUANTOS MÓDULOS TENEMOS CONECTADOS EN SERIE?

int maxInUse = 2;
// DEFINIMOS LA FUNCIÓN DE CADA PIN
Página 344/400
MaxMatrix m(data, load, clock, maxInUse);
byte buffer[10];
// ESTA ES LA VARIABLE QUE CONTIENE EL TEXTO QUE APARECERÁ EN

LOS DISPLAYS
char string1[] = "Esto es una prueba de texto en scroll ";
void setup(){
m.init(); // INICIAMOS EL MODULO
m.setIntensity(5); // DEFINIMOS LA INTENSIDAD DE LOS LED (0-15)
}
void loop(){
byte c;
delay(100); // PAUSA ENTRE MOVIMIENTOS
m.shiftLeft(false, true);
printStringWithShift(string1, 100); // ENVIAMOS EL TEXTO A LOS MODULOS
}
// FUNCIONES PARA MOSTRAR LOS CARACTERES EN EL DISPLAY DE LOS

MODULOS
void printCharWithShift(char c, int shift_speed){
if (c < 32) return;
c -= 32;
memcpy_P(buffer, CH + 7*c, 7);
m.writeSprite(maxInUse*8, 0, buffer);
m.setColumn(maxInUse*8 + buffer[0], 0);
for (int i=0; i<buffer[0]+1; i++)

{
delay(shift_speed);
Página 345/400
m.shiftLeft(false, false);
}
}
void printStringWithShift(char* s, int shift_speed){
while (*s != 0){
printCharWithShift(*s, shift_speed);
s++;
}
}
Usar matrices de leds en nuestro proyecto es una buena forma de incorporar

señales de aviso, alertas de estado o simplemente animaciones graciosas. En
este caso vamos a ver como alternar imágenes para crear una animación sencilla
de 2 frames usando la librería LEDControl.h.
Al igual que con la otra librería, la descargamos y descomprimimos en la carpeta
Libraries de nuestra instalación del IDE de Arduino. El código esta comentado
para que sea fácil de entender. Aquí esta el enlace para descargarla:
#include "LedControl.h"
//Declaramos los pines: DIN, CLK, CS y el nº de displays conectados en serie

LedControl lc=LedControl(8,10,9,2);
//Pausa entre frames

unsigned long delayTime=900;
//Codigo de los 2 frames que vamos a mostrar:
//Corazón pequeño
byte Heart1[] = {
B00000000,
B01100110,
B11111111,
B11111111,
B01111110,
B00111100,
B00011000,
B00000000};
Página 346/400
//Corazón grande
byte Heart2[] = {
B01100110,
B11111111,
B11111111,
B11111111,
B11111111,
B01111110,
B00111100,
B00011000};
//Sub para transformar array #1 en un patron para la matriz

void Heart1GO()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0,i,Heart1[i]);
}
}
//Sub para transformar array #2 en un patron para la matriz

void Heart2GO()
{
for (int i = 0; i < 8; i++)
{
}
}
//Esta sub se ejecutará 1 sola vez al arrancar el Arduino

void setup() {
lc.shutdown(0,false); //Iniciamos la matriz led #1
lc.shutdown(1,false); //Iniciamos la matriz led #2
lc.setIntensity(0,5); //Intensidad de los led en la matriz #1
lc.setIntensity(1,5); //Intensidad de los led en la matriz #2
lc.clearDisplay(0); //Apagamos todos los led de la matriz #1
lc.clearDisplay(1); //Apagamos todos los led de la matriz #2
}
//Esta sub se ejecutara en bucle una y otra vez mientras el Arduino este alimentado.
void loop() {
Heart1GO(); //Mostramos el patrón #1
delay(delayTime); //Pequeña pausa
Heart2GO(); //Mostramos el patrón #2
Página 347/400
delay(delayTime); //Pequeña pausa
}
Creando patrones en binario
Como hemos visto en los ejemplos anteriores cada dígito o carácter esta
compuesto de un código en binario que define el estado de cada led de la matriz.
Para generar estos códigos de forma fácil y rápida hemos diseñado una pequeña
aplicación para Windows basada en una herramienta online que descubrimos
hace algún tiempo.
Como se puede ver en la imagen esta formado por una matriz de 8×8 checkboxes, cada checkbox
define el estado de 1 led de la matriz. Para generar un patrón marcamos los checkbox deseados
hasta conformar una imagen al estilo pixel art. En la siguiente imagen se ve un corazón generado
por el programa.
Página 348/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 349/400
Grado: _____________________ Grupo ____________________________
Actividad 10


Página 350/400
Practica 44).-Desarrollar un programa de control de display LCD de
4 líneas con I2C y sin control serial.
Objetivo: Aplicar su conocimiento sobre programación y desarrollar un programa
que controle un display LCD que muestre el msg CBTIS 47 Mecatronica 2018 y
una carita feliz cerrando un ojo y un corazón latiendo modo gráfico
Tarea 5: Investigar sobre I2C protocolo para micros

Complemento Apuntes 5 Sobre Display LCD 4 líneas programación


Actividad 2 Analizar el Diagrama de Flujo de la figura 1.0
Actividad 3 Desarrolle el código.
Actividad 4 Desarrollar el programa tomando como ejemplo el circuito mostrado.
Actividad 6 Armar el circuito de la figura 1.1
Página 351/400
MANEJO DE DISPLAY LCD
El LCD(Liquid Crystal Dysplay) o pantalla de cristal líquido es un dispositivo

mpleado para la visualización de contenidos o información de una forma gráfica,
mediante caracteres, símbolos o pequeños dibujos dependiendo del modelo. Está
gobernado por un microcontrolador el cual dirige todo su funcionamiento.
Una alternativa cada vez más utilizada es conectar la pantalla LCD 2x16 mediante
bus i2c para simplificar la conexión utilizando un módulo de conexión i2c
específico:
Página 352/400
Conectaremos una pantalla LCD según el siguiente esquema y realizaremos un
programa para mostrar mensajes de prueba
Conectar la pantalla LCD con el módulo i2c.

Conectar un potenciómetro a la entrada analógica A0.
https://www.geekfactory.mx/tutoriales/tutoriales-arduino/lcd-16x2-por-i2c-con-
arduino/
Página 353/400
Hardware del Módulo adaptador LCD a I2C
El Módulo adaptador LCD a I2C que usaremos está basado en el controlador I2C
PCF8574, el cual es un Expansor de Entradas y Salidas digitales controlado por I2C. Por el
diseño del PCB este módulo se usa especialmente para controlar un LCD Alfanumérico.
La dirección I2C por defecto del módulo puede ser 0x3F o en otros casos 0x27. Es muy
importante identificar correctamente la dirección I2C de nuestro modulo, pues de otra
forma nuestro programa no funcionará correctamente. Para identificar la dirección
especifica de nuestro módulo podemos utilizar un pequeño sketch de prueba llamado: I2C
Scanner, el cual nos permite identificar la dirección I2C del dispositivo conectado al
Arduino. Si en caso existiera la necesidad de trabajar con más de un LCD podemos
modificar la dirección I2C del modulo adaptador. Para esto es necesario soldar los puentes
A0, A1 y A2 presentes en el módulo, estos tres puentes son los bits menos significativos de
la dirección I2C del módulo. La dirección 0x3F en binario sería: 0|0|1|1|1|A2|A1|A0 y la
dirección 0x27: 0|0|1|0|0|A2|A1|A0. Por defecto A0, A2, A1 valen 1 pero si soldamos los
puentes, estos se conectan a tierra teniendo un valor 0. Por ejemplo si soldamos los tres
puentes la nueva dirección sería 0|0|1|0|0|0|0|0 (0x20), para un chip que anteriormente era
0x27.
Página 354/400
Para controlar el contraste de los dígitos en el LCD solo necesitamos girar el potenciómetro
que se encuentra en el módulo, hasta quedar conformes con el contraste mostrado.
La luz de fondo se controla principalmente por software desde el Arduino, pero el módulo
también permite desconectar el Led de la luz de fondo removiendo un jumper LED.
Conexiones entre Arduino y Módulo adaptador LCD a I2C
El adaptador LCD a I2C tiene los pines ordenados para conectar directamente al LCD, esto
lo podemos hacer a través de un protoboard o soldando directamente al LCD.
Para conectar con el modulo con el Arduino solo utilizamos los pines I2C del Arduino (SDA y SCL) y
alimentación (GND y 5V), los pines I2C varían de acuerdo al modelo de Arduino con el que
trabajemos, en la siguiente tabla podemos ver cuales son los pines I2C para cada modelo de
Arduino.
Las conexiones para el LCD 20 x 4 son las mismas.
Librería LiquidCrystal_I2C para Arduino
Existen diferentes tipos y versiones de librerías para trabajar con el módulo Adaptador
LCD a I2C, información más completa pueden encontrar en:
http://playground.arduino.cc/Code/LCDi2c , nosotros usaremos la
librería LiquidCrystal_I2C
Las funciones que utiliza esta librería son similares a la librería LiquidCrystal de Arduino,
revisaremos las funciones principales:
LiquidCrystal_I2C(lcd_Addr, lcd_cols, lcd_rows)
Función constructor, crea un objeto de la clase LiquidCrystal_I2C, con dirección, columnas

y filas indicadas.
init()
Inicializa el modulo adaptador LCD a I2C, esta función internamente configura e inicializa
el I2C y el LCD.
Página 355/400
clear()
Borra la pantalla LCD y posiciona el cursor en la esquina superior izquierda (posición

(0,0)).
setCursor(col, row)
Posiciona el cursor del LCD en la posición indicada por col y row(x,y); es decir, establecer
la ubicación en la que se mostrará posteriormente texto escrito para la pantalla LCD.
print()
Escribe un texto o mensaje en el LCD, su uso es similar a un Serial.print
scrollDisplayLeft()
Se desplaza el contenido de la pantalla (texto y el cursor) un espacio hacia la izquierda.
scrollDisplayRight()
Se desplaza el contenido de la pantalla (texto y el cursor) un espacio a la derecha.
backlight();
Enciende la Luz del Fondo del LCD
noBacklight();
Apaga la Luz del Fondo del LCD
createChar (num, datos)
Crea un carácter personalizado para su uso en la pantalla LCD. Se admiten hasta ocho
caracteres de 5x8 píxeles (numeradas del 0 al 7). Dónde: num es el número de carácter y
datos es una matriz que contienen los pixeles del carácter. Se verá un ejemplo de esto más
adelante.
Ahora que hemos repasado la librería veamos algunos ejemplos:
Ej 1. Un Hola mundo con Arduino y LCD
Mostraremos texto y un valor numérico en el LCD, para esto cargamos el siguiente sketch:
Página 356/400
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
//Crear el objeto lcd dirección 0x3F y 16 columnas x 2 filas

LiquidCrystal_I2C lcd(0x3F,16,2); //
void setup() {
// Inicializar el LCD
lcd.init();
//Encender la luz de fondo.

lcd.backlight();
// Escribimos el Mensaje en el LCD.

lcd.print("Hola Mundo");
}
void loop() {
// Ubicamos el cursor en la primera posición(columna:0) de la segunda
línea(fila:1)
lcd.setCursor(0, 1);
// Escribimos el número de segundos trascurridos
lcd.print(millis()/1000);
lcd.print(" Segundos");
delay(100);
}
Página 357/400
La programación es similar para un LCD de 20x4, solo hay que modificar en:
LiquidCrystal_I2C lcd(0x27,20,4);
Ej 2. Desplazando el texto en el LCD
En este ejemplo para desplazar el texto usaremos la función scrollDisplayLeft(). El codigo

es el siguiente:
#include <Wire.h>

void setup() {
lcd.init();

lcd.backlight();
// Escribimos el Mensaje en el LCD en una posición central.

lcd.print("WWW.NAYLAMPMECHATRONICS.COM");
lcd.print("Tutorial LCD, Test de desplazamiento ");
}
void loop() {
//desplazamos una posición a la izquierda
lcd.scrollDisplayLeft();
delay(500);
}
Página 358/400
Ej 3. Mostrando datos de sensores o variables en el LCD
En este ejemplo mostramos en el LCD variables, que pueden representar valores de

sensores u otros datos. Para simular los sensores usaremos potenciómetros conectados a
los puertos analógicos.
#include <Wire.h>

void setup() {
lcd.init();

lcd.backlight();
void loop() {
int sen1=analogRead(A0);
float sen2=analogRead(A1)*(5.0 / 1023.0);
float sen3=analogRead(A2)*(100.0 / 1023.0);
int tiempo=millis()/1000;
// Cursor en la primera posición de la primera fila
Página 359/400
lcd.setCursor(0,0);
lcd.print("ADC:");
lcd.print(sen1);
lcd.print(" ");
// Cursor en la 11° posición de la primera fila
lcd.setCursor(10,0);
lcd.print("V:");
lcd.print(sen2,1);//1 decimal
lcd.print("V ");
// Cursor en la primera posición de la 2° fila
lcd.setCursor(0,1);
lcd.print("T:");
lcd.print(sen3,1); //1 decimal
lcd.print("337C "); // "337" -> "°"
// Cursor en la 11° posición de la 2° fila
lcd.setCursor(10,1);
lcd.print("t:");
lcd.print(tiempo);
lcd.print(" s ");
delay(200);
Página 360/400
Ej 4. Agregando nuevos caracteres a nuestro LCD
En algunos casos el LCD no incluye por defecto los caracteres que necesitamos, o
deseamos dibujar caracteres personalizados, en este caso usamos la función createChar ()
pero antes estudiemos como está constituido un carácter:
Un carácter está formado por una matriz de 5x8 pixeles los cuales se representan por 8
bytes, uno para cada fila, los 5 bits menos significativos representan los pixeles del
carácter:
Como máximo podemos crear 8 caracteres nuevos.
Para este ejemplo crearemos los siguientes caracteres:
Página 361/400
#include <Wire.h> };
#include <LiquidCrystal_I2C.h> byte P[8] = {
B11111,
//Crear el objeto lcd dirección B10001,
0x3F y 16 columnas x 2 filas B10001,
LiquidCrystal_I2C lcd(0x3F,16,2); B10001,
// B11111,
byte N[8] = { B10000,
B11111, B10000,
B10001, B00000,
B10001, };
B10001, byte cara[8] = {
B10001, B00000,
B10001, B10001,
B10001, B00000,
B00000, B00000,
}; B10001,
byte A[8] = { B01110,
B11111, B00000,
B10001, };
B10001, byte cuerpo[8] = {
B10001, B01110,
B10001, B01110,
B11111, B00100,
B10001, B11111,
B00000, B00100,
}; B01010,
byte Y[8] = { B10001,
B10001, B00000,
B10001, };
B10001,
B10001, void setup() {
B11111, // Inicializar el LCD
B00100, lcd.init();
B00100,
B00000, //Encender la luz de fondo.
}; lcd.backlight();
byte L[8] = {
B10000, //creamos los nuevos caracteres
B10000, lcd.createChar (0,N);
B10000, lcd.createChar (1,A);
B10000, lcd.createChar (2,Y);
B10000, lcd.createChar (3,L);
B10000, lcd.createChar (4,M);
B11111, lcd.createChar (5,P);
B00000, lcd.createChar (6,cara);
}; lcd.createChar (7,cuerpo);
byte M[8] = { // Escribimos el texto en el LCD
B11111, lcd.setCursor(0, 0);
B10101, lcd.print("Tutorial LCD_I2C");
B10101, lcd.setCursor(0, 1);
B10101, lcd.write (byte (7));
B10101, lcd.print(" ");
B10101, lcd.print(" ");
Página 362/400
lcd.write (byte (1));
Página 363/400
lcd.print(" ");
lcd.print(" ");
void loop () {}
El resultado del ejemplo anterior es el siguiente:
Página 364/400
Mostrar el funcionamiento de su trabajo al profesor, si tienen dudas preguntar, pues le
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 365/400
Grado: _____________________ Grupo ____________________________
Actividad 10
Hacer su reporte a computadora siguiendo la tipografía indicada en el Anexo A de este

manual, tomando los datos de este borrador. El reporte será UNO por equipo.

Página 366/400
Practica 45).- Armado y prueba de chasis del circuito giratorio de led´s.
Objetivo: Arme el prototipo de un arreglo giratorio de led´s y el circuito de control de
velocidad anterior, y desarróllelo físicamente use 5 led´s RGB. Vea ejemplos.
Tarea 5 Investigar sobre Control de leds Giratorios.
Actividad 1
Armar el circuito de control de velocidad y control de led:
Actividad 2
Plantear una hipótesis del funcionamiento de su circuito para solucionar la problemática
requerida.
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
Actividad 3
Página 367/400
funcionamiento del circuito empleando y sensor requerido. Vea aquí unos ejemplos de
cómo puede quedar su trabajo.
Página 368/400
Ejemplo de circuito propuesto.
Página 369/400
Actividad 4
Describir el funcionamiento del circuito que soluciona la problemática.
R: _________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
Actividad 5
Anotar conclusiones y recomendaciones.
R: __________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
R: __________________________________________________________________
__________________________________________________________________
__________________________________________________________________
Página 370/400
Actividad 6
Prueba y programa demo del circuito giratorio de led´s.

Desarrollar un programa para microcontrolador que prenda de manera ALEATORIA

LOS LEDS.
Desarrolle una tabla donde dibuje la forma en que prenderán los led´s en un rango
máximo y mínimo en la escala de tiempo marcada por las RPM del controlador de
velocidad.
Ejemplo de su tabla de rangos, supongamos una velocidad de 1200 RPM
Página 371/400
Página 372/400
Actividad 7
Plantear una hipótesis del funcionamiento de su programa para solucionar la
R: __________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
Actividad 8

funcionamiento del circuito empleando y sensor requerido. Vea aquí unos ejemplos de
cómo puede quedar su trabajo.
Página 373/400
Circuito PCB
Página 374/400
PCB DE TIRA MONOCROMATICA DE LED S
Página 375/400
Actividad 9
Describir el funcionamiento del programa que soluciona la problemática.
R: _________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
Actividad 10
Anotar conclusiones y recomendaciones. Anexar código fuente de programación
R: __________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
R: __________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
Página 376/400
Actividad 11
Anexar código fuente de programación y Mostrar el funcionamiento de su trabajo al

profesor, si tienen dudas preguntar, pues le deberá quedar completamente claro el
funcionamiento de su circuito.
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 377/400
Grado: _____________________ Grupo ____________________________
Actividad 12
Tarea 5.2 Investigar sobre programación de pic y tarjetas entrenadoras de circuitos

electrónicos.

Página 378/400
Practica 46).- Comunicación serie entre arduinos maestro-escavo encender un
Led.
Objetivo General: El alumno aprenderá la comunicación serie entre arduinos para
aplicación electrónica.
Problemática: Prender y apagar un led de forma remota por cable Tx Rx Serie ó
I2C mandando de un arduino maestro a uno esclavo y este último deberá prender
el led, indicándole al arduino maestro que ya se ha efectuado la acción, esto se
logra mediante un sensor de luz que detecte el encendido.
Desarrollo:
El proceso es parecido al bluetooth. Aquí queremos que una Arduino envíe
(MAESTRO) y que otra reciba (ESCLAVO), así que cada una correrá un programa
distinto.
Podemos hacer también que ambas tarjetas envíen y reciban datos, para ello, la
modificación sobre lo que expongo aquí serían muy sencillas, (básicamente copiar y
pegar los trozos de código intercambiados).
Conexiones:
Usaremos los pines estándar de comunicación serie de Arduino:
 0 : RX (pin por el que RECIBE los datos serie)
 1 : TX (pin por el que ENVÍA los datos serie)
Para comunicación en 2 direcciones (los 2 pueden enviar / recibir).
Las conexiones TX/RX se intercambian (lo que uno envía -TX- tiene que entrar en el
otro -RX-).
Cualquiera de las 2 puede ser Maestro o Esclavo
IMPORTANTE: Conectar ambas GND de las placas.
Página 379/400
Para la comunicación en una dirección:
[ maestro(izquierda)->esclavo(derecha) ] sólo necesitamos 1 conexión:
NOTA:
Ocurre que esos pines también los usa para comunicarse por USB cuando está
conectado al ordenador, de manera que si queremos tener ambas conexiones
(USB/trasmisión serie) deberemos crear una nueva conexión serie (en una conexión
software).
En este ejemplo, una de las Arduino la vamos a tener conectada al PC, por tanto, en el
MAESTRO vamos a crear la conexión software serie sobre los pines 10(RX), 11(TX).
Lo puedes comprobar en la siguiente imagen:
Página 380/400
Ejemplo de Código
Página 381/400
Actividades:
1- Plantear las conexiones requeridas para prender y apagar el led.
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------

--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
Página 382/400
3- Desarrollar el código fuente de programación.
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
4- Al momento de la revisión se le indicara un puerto de comunicación X y usted

deberá programarlo antes de hacerlo físicamente y comprobarlo para ser
aceptada su práctica.
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 383/400
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Grado: _____________________ Grupo ____________________________
Tarea 7 Investigar sobre comunicación maestro esclavo en arduinos
Actividad 6

Página 384/400
Practica 47).- Comunicación serie entre arduinos. Hacer un Chat entre dos
arduinos.
Objetivo General: El alumno aprenderá la comunicación entre arduinos para aplicación
de mensajería electrónica.
Problemática: Prender y apagar un led de forma remota por cable Tx Rx Serie ó I2C
mandando de un arduino maestro a uno esclavo y este último deberá prender el led,
indicándole al arduino maestro que ya se ha efectuado la acción, esto se logra
mediante un sensor de luz que detecte el encendido.
Desarrollo:
El proceso es parecido al bluetooth. Aquí queremos que una Arduino envíe
(MAESTRO) y que otra reciba (ESCLAVO), así que cada una correrá un programa
distinto.
Podemos hacer también que ambas tarjetas envíen y reciban datos, para ello, la
modificación sobre lo que expongo aquí serían muy sencillas, (básicamente copiar y
pegar los trozos de código intercambiados).
Conexiones:
Usaremos los pines estándar de comunicación serie de Arduino:
 0 : RX (pin por el que RECIBE los datos serie)
 1 : TX (pin por el que ENVÍA los datos serie)
Para comunicación en 2 direcciones (los 2 pueden enviar / recibir).
Las conexiones TX/RX se intercambian (lo que uno envía -TX- tiene que entrar en el
otro -RX-).
Cualquiera de las 2 puede ser Maestro o Esclavo
IMPORTANTE: Conectar ambas GND de las placas.
Página 385/400
Una forma de hacerlo es
El programa que comunique por puerto serie un arduino UNO (usar la librería software
serial) con otro Arduino UNO y saque por pantalla (puerto serie HW del USB) lo recibido
por el puerto serie SW y mande por el puerto serie SW todo aquello que mandes desde
el terminal. Es decir, hacer un chat punto a punto entre dos Arduinos. Funciones y
librerías a usar:
 Librería softwareSerial: http://arduino.cc/en/Reference/SoftwareSerial

 Funciones software serial: softwareSerial(), begin(), available(), print(), listen(),
write()-
 Solo puede recibir por un puerto softwareSerial simultáneamente, no todos los

pines soportan interrupciones de cambio. Ver limitaciones en
https://www.arduino.cc/en/Reference/SoftwareSerial
 Otra librería softwareSerial alternativa a la incluida en el core de Arduino:

http://www.pjrc.com/teensy/td_libs_AltSoftSerial.html últil cuando hay varios flujos
de datos simultaneos.
Otra forma de hacerlo en una versión mejorada del anterior chat, de forma que al
escribir en el monitor serie la cadena “repite”, Arduino pregunte cuantas veces y mandar
por el chat serie la cadena “repite” tantas veces como se haya indicado. En este caso la
estrategia es diferente, en lugar de leer un carácter del buffer en cada loop, en este
caso hay que leer todo el buffer en el mismo loop para analizar lo que he recibido. Otra
estrategia sería leer en cada loop línea por línea.
Página 386/400
Comprobar las luces de Tx, Rx cada vez que se manda o recibe datos. Se podría hacer
lo mismo con unos LEDs en los pines 10 y 11, encendiendo los leds cada vez que
hagamos un write() o un read() en el puerto serie software y veríamos si se están
mandando datos o no por la comunicación serie entre los dos Arduinos.
Página 387/400
Ejemplo de Código
/* Ejercicio22-ChatSerie para el curso #aprendiendoarduino

No todos los pines soportan interrupciones de cambio
The circuit:
RX is digital pin 10 (connect to TX of other device)
TX is digital pin 11 (connect to RX of other device)
*/
// Ojo a las limitaciones y temas de interrupciones!!!
// http://arduino.cc/en/Reference/SoftwareSerial
// Basado en: http://www.instructables.com/id/Simple-Chat-Program-with-Arduino-
Uno/?ALLSTEPS
#include <SoftwareSerial.h>
SoftwareSerial mySerial(10, 11); // RX, TX
void setup() {
Serial.begin(9600);
Serial.println("Starting Chat Program...");
mySerial.begin (4800); //probar a poner velocidades diferentes en cada punto.
delay(1000);
mySerial.println("Hola, acabo de iniciar el chat");
}
void loop() { //en cada loop leo un caracter si hay en alguno de los bufferes
if (mySerial.available()) {
Serial.print((char)mySerial.read());
}
if (Serial.available()) {
mySerial.print((char)Serial.read());
}
}
Página 388/400
AsÍ se vería su CHAT
Actividades:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 389/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
6- Al momento de la revisión se le indicara una comunicación X y usted deberá

programarlo antes de hacerlo físicamente y comprobarlo para ser aceptada su
práctica.
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 390/400
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Grado: _____________________ Grupo ____________________________
Tarea 8 Investigar sobre comunicación CHAT en arduinos
Actividad 6

Página 391/400
Practica 48).- Comunicación RF entre arduinos maestro esclavo para mover un
Móvil.
Objetivo General: El alumno aprenderá la comunicación RF entre arduinos para
controlar un móvil.
Problemática: Controlar de forma remota por RF mandando de un arduino maestro a
uno esclavo y este último deberá manipular un vehículo.
Desarrollo:
Con este prototipo básico vamos a sentar las bases para poder mover nuestros vehículos y robots,
controlados con Arduino/Genuino, mediante control remoto, usando un joystick y los módulos de
Radio-Frecuencia. Al accionar nuestro joystick en un equipo emisor, obtendremos diferentes respuestas
de unos LEDs en el equipo receptor.
Los equipos de Radio-Frecuencia están compuestos dos módulos, un transmisor y un receptor
inalámbricos que funcionan a 315Mhz. . Dado que sólo uno de ellos es transmisor, la comunicación de
datos sólo funcionará en un sentido, por lo que se necesitan dos pares (de diferentes frecuencias) para
actuar como un par transmisor / receptor.
Los módulos de RF de bajo coste requieren un formato especial de datos, con patrones de
sincronización, equilibrio de bits 0 y 1, y comprobación de errores. VirtualWire ofrece todas estas
características, lo que permite un mejor rendimiento de los circuitos de radio muy baratos.
Puedes encontrar sus funcionamiento básico de esta biblioteca en:
www.web-robotica.com/arduino/como-utilizar-los-modulos-rf-transmisor-y-receptor-315mhz-con-
arduino
Página 392/400
Una forma de hacerlo es
Para este prototipo vamos a construir dos equipos, el equipo emisor y el receptor.
El equipo emisor, que controla remotamente al equipo receptor, está compuesto por
una placa Arduino/Genuino, un joystick y el Módulo emisor de Radio-Frecuencia.
Para las diferentes posiciones del joystick vamos a emitir diferentes caracteres. Estos
caracteres actuarán sobre diferentes LEDs en el módulo receptor. El equipo receptor
está compuesto por una placa Arduino/Genuino, un módulo receptor y cuatro LEDs.
Componentes y materiales
 2 Placas Arduino/Genuino
 1 Módulo joystick
 1 Módulo Emisor RF
 1 Módulo Receptor RF
 4 LEDs
 4 Resistencias
 Protoboard
 Cables de conexión
Emisor de Control Remoto
Página 393/400
Para el equipo emisor tenemos que conectar el módulo emisor y el joystick a la
placa Arduino/Genuino. El módulo emisor lo conectamos a +5V, a GND, y al pin 12 de la
placa Arduino/Genuino. El Joystick lo conectamos a +5V, a GND, la señal X y la señal Y los conectamos a
los pines analógicos A0 y A5 de la placa Arduino/Genuino ,y el pulsador lo conectamos al pin 2 de la
placa Arduino/Genuino.
Receptor de Control Remoto
Para el equipo receptor tenemos que conectar el módulo receptor y los LEDs junto con las resistencias a
la placa Arduino/Genuino. El módulo receptor lo conectamos a +5V, a GND, y al pin 12 de la
placa Arduino/Genuino. Los LEDs los conectamos a GND, y a los pines 4, 5, 6 y 7 de la
placa Arduino/Genuino.
Página 394/400
Página 395/400
Código Arduino para el equipo emisor ejemplo
#include <VirtualWire.h>
boolean running = true;
char *controller;
int xPin = A5;
int yPin = A0;
int buttonPin = 2;
int xPosition = 0;
int yPosition = 0;
int buttonState = 1;
void setup() {
Serial.begin(9600);
pinMode(xPin, INPUT);
pinMode(yPin, INPUT);
pinMode(13,OUTPUT);
vw_set_ptt_inverted(true); //
vw_set_tx_pin(12);
vw_setup(4000);// speed of data transfer Kbps
}
void loop(){
xPosition = analogRead(xPin);
yPosition = analogRead(yPin);
buttonState = digitalRead(buttonPin);
Serial.print("X: ");
Serial.print(xPosition);
Serial.print(" | Y: ");
Serial.print(yPosition);
Serial.print(" | Emitiendo: ");
Serial.println(controller);
if (xPosition <= 300 && 300 > yPosition < 700)

{
controller="4" ;
vw_send((uint8_t *)controller, strlen(controller));
vw_wait_tx(); // Wait until the whole message is gone
digitalWrite(13,1);
}
else if ( 300 > yPosition < 700 && xPosition > 700)
{
controller="6" ;
Página 396/400
digitalWrite(13,1);
}
else if (300 > xPosition < 700 && yPosition > 700)
{
controller="5" ;
digitalWrite(13,1);
}
else if (300 > xPosition < 700 && yPosition <= 300)
{
controller="7" ;
digitalWrite(13,1);
}
else if (300 > xPosition < 700 && 300 > yPosition < 700)
{
controller="0" ;
digitalWrite(13,0);
}}
Como funciona el módulo joystick

El módulo joystick nos va a proporcionas una señal analógica para el movimiento en el
eje X, y otra señal para el eje Y.
Dependiendo de la cantidad de señal en cada entrada activará una señal que podemos
utilizar para controlar diferentes aparatos, como LEDs, motores, etc.
www.web-robotica.com/arduino/como-utilizar-el-modulo-joystick-con-arduino
Página 397/400
Código Arduino para el equipo receptor ejemplo
Este código controla el receptor de manera que cuando recibe el mensaje ‘4’ activa el
pin 4, si recibe ‘5’ activa el pin 5, si recibe ‘6’ activa el pin 6, y si recibe ‘7’ activa el pin 7.
// Incluimos la biblioteca VirtualWire
#include <VirtualWire.h>
void setup()
{
vw_set_ptt_inverted(true); // Requerido para DR3100
vw_set_rx_pin(12);
vw_setup(4000); // Bits por segundo
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
vw_rx_start(); // Inicia el receptor

}
void loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen))
{
// Si recibe '0' no activa ningún pin
if(buf[0]=='0'){
digitalWrite(4,0);
digitalWrite(5,0);
digitalWrite(6,0);
digitalWrite(7,0);
}
// Si recibe '4' activa el pin 4
if(buf[0]=='4'){
digitalWrite(4,1);
digitalWrite(5,0);
digitalWrite(6,0);
digitalWrite(7,0);
}
if(buf[0]=='5'){
digitalWrite(4,0);
digitalWrite(5,1);
digitalWrite(6,0);
digitalWrite(7,0);
Página 398/400
}
if(buf[0]=='6'){
digitalWrite(4,0);
digitalWrite(5,0);
digitalWrite(6,1);
digitalWrite(7,0);
}
if(buf[0]=='4'){
digitalWrite(4,0);
digitalWrite(5,0);
digitalWrite(6,0);
digitalWrite(7,1);
}}}
Actividades:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 399/400
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
3- Al momento de la revisión se le indicara una comunicación X y usted deberá

programarlo antes de hacerlo físicamente y comprobarlo para ser aceptada su
práctica.
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 400/400
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Grado: _____________________ Grupo ____________________________
Tarea 9 Investigar sobre comunicación RF entre arduinos
Actividad 6

Página 401/400
Practica 49).- Desarrollar un circuito de una resistencia digital
programada por arduino.
Objetivo: Que el circuito se pueda programas un valor digitamente y que refleje en un

displat LCD el valor de la resistencia programada .
Tiempo para desarrollo la Practica
Lectura de Práctica y Análisis -- 15 min

Programación ---- 1 horas
Armado de Circuito ---- 1 horas

Actividad 5 Compilar el programa verificar que no tenga errores y de ser asi componer
el programa hasta que funcione correctamente.
Actividad 8 Verifique el buen funcionamiento de su programa y circuito, de no ser asi
modifique hasta que dé el resultado indicado en el objetivo de la práctica.
Página 402/400
Actividad 9) Analizar la solución tomando en cuenta la figura siguiente
R = 1000 ohms
Potenciómetros digitales
El circuito integrado X9C103P forma parte de una familia de circuitos integrados que
tienen la función de un potenciómetro. Entre la «C» y la «P» se coloca una numeración.
En este caso es 103, lo que significa 10×10^3. Eso equivale a 10000 Ohm, es decir,
10KOhm por lo que el circuito X9C103P solamente podrá alcanzar un valor máximo de
10K.
Existen los modelos 102 (1K), 104(100 K) y 503(50K). Cada uno es un arreglo de 100
resistencias. En el modelo de 10K cada resistencia es de 100 Ohm. En el modelo de 1
K son 100 resistencias de 10 Ohm; en el modelo de 50K son 100 resistencias de 500
Ohm; en el modelo de 100K son 100 resistencias de 1 K cada una.
Estos potenciómetros pueden ser adquiridos desde Mouser, Jameco, Ebay, Amazon,
etc. El precio es bastante accesible, lo cual permite considerar este tipo de circuito
como una opción viable para los proyectos en los que sea necesario emplearlos
Página 403/400
Características del circuito integrado
El esquemático de esta familia de circuitos integrados es el siguiente:
Pin No. Nombre del Pin Descripción

1 INC Incremento. Cuando se le aplica una señal de onda cuadrada
en esta pata el circuito aumenta o reduce el valor de su
resistividad dependiendo del estado en que se encuentre la
pata U/D
2 U/D Up/Down. Dependiendo del estado de esta pata cuando se

aplique una onda cuadrada en el INC el valor de la resistencia
subirá o bajará.
3 VH/RH Este es el equivalente de una de las patas del potenciómetro,

específicamente una de las 2 patas situadas en los extremos.
4 VSS Voltaje de salida (GND) del circuito. Se conecta a tierra.
5 VW/RW Este es el equivalente una de las tres patas del potenciómetro,

específicamente la pata del centro. Se le llama “wiper”
6 VL/RL Este es el equivalente de una de las patas del potenciómetro,

específicamente una de las 2 patas situadas en los extremos.
7 CS Esta pata es prácticamente el activador/desactivador del

dispositivo. Cuando está en estado LOW es posible cambiar la
resistividad del potenciómetro. Una vez pase a un estado HIGH
el circuito guardará la resistencia en dicho instante en una
memoria no volátil que es capaz de mantener dicho valor por
un periodo muy extenso, siendo posible guardar una
configuración por un tiempo de hasta 100 años.
Página 404/400
8 VCC Voltaje de entrada (V+) del circuito. Se conecta al voltaje de
alimentación.
Para configurar este circuito integrado necesitamos una serie de combinaciones de

estados HIGH/LOW, lo que hace un poco complicado utilizarlo de forma manual. Sin
embargo utilizando un micro controlador como Arduino se hace muy fácil aumentar,
reducir y guardar la resistividad en este circuito.
Utilizando el potenciómetro con Arduino
Ahora vamos a armar un sencillo diagrama con el que nos será posible manipular el
estado del circuito con Arduino.
Como vemos es muy fácil de usar.

 Conectamos la pata 1 al pin 2 de Arduino, la pata 2 al pin 3, la pata 7 al pin 4.
 La pata 4 va a GND y la pata 8 va a V+.
 Entre las patas 3 y 5, o bien, 5 y 6 es donde medimos la resistencia.
Recordemos que en los potenciómetros mecánicos tenemos 2 opciones, medir la
resistencia entre la pata 1 y 2 y entre la pata 2 y 3.
 Acá es lo mismo, solo usaremos la 5 y 6 o la 3 y la 5.
Página 405/400
La programación de Arduino se hace completamente sencilla a través del uso de una
librería escrita por Timo Fager. Se llama DigiPotX9Cxxx y la podemos encontrar en el
siguiente enlace:
http://sites.google.com/site/tfagerscode/home/digipotx9cxxx
Recuerden que hay que copiar el contenido de la carpeta que descargamos en la
carpeta libraries en la raíz de Arduino, es decir, la carpeta donde tenemos instalado
Arduino IDE.
El código a usar es el siguiente:
#include <DigiPotX9Cxxx.h>
DigiPot pot(2,3,4);
int input;
void setup() {
Serial.begin(115200);
}
void loop() {
if (Serial.available()>0){
inpue=Serial.read();
if (input=='1'){
pot.increase(1);
}
else
{
pot.decrease(1);
}
}
}
Subiendo este código a Arduino, abrimos el Monitor Serial. Con enviar un «1»
aumentaremos la resistencia la cantidad de veces que enviemos el uno. Con un «0» o
cualquier otro carácter reduciremos la resistencia.
El valor mínimo será cercano a 0 y el valor máximo será próximo a 10K.
Página 406/400
Página 407/400
Actividad 10
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 408/400
Grado: _____________________ Grupo ____________________________
Actividad 11

Página 409/400
Practica 50).- Desarrollar un Vehículo controlado por ACELEROMETRO.
Objetivo: Que el vehículo móvil sea capaz de cambiar su dirección controlando por
acelerómetro. Se recomienda el uso de un guante.
Tiempo para desarrollo de la práctica


modifique hasta que dé el resultado indicado en el objetivo de la práctica.
Página 410/400
MPU 6050
Descarga las librerias y ejemplos del MPU6050:

https://drive.google.com/open?id=1VYT...
Todo acerca del Sensor MPU 6050 - Acelerometro - Giroscopio - Caracteristicas Tecnicas
https://www.youtube.com/watch?v=awjXz...
Página 411/400
Actividad 9
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 412/400
Grado: _____________________ Grupo ____________________________
Actividad 10

Página 413/400
EXAMEN UNIDAD 3).- Desarrollar un circuito de control para un CUBO DE
LEDS 5x5, que muestre los números del 0 al 9 seleccionados con un
control remoto IR.
Objetivo: que el circuito pase el número seleccionado de una cara a otra del cubo, ver
figura
Tiempo para desarrollo de Examen

Tiempo total 3 días.

modifique hasta que dé el resultado indicado en el objetivo de la práctica..
Página 414/400
Figura A
Figura B
Figura C
Figura D
Página 415/400
Ejemplo de un cubo de leds de 3x3
Se muestra un ejemplo de como conectarlo y se anexa el código fuente del mismo para
su compilación y uso. Se espera lo tome como ejemplo para desarrollar el propio.
Página 416/400
Programa
/*
ledcube.pde - Example sketch for controlling an LED cube.
Created by Gamaiel Zavala (gzip), 2009-2012
MIT License. See accompanying LICENSE file for terms.
*/
#include <LedCube.h>
#define SIZE 3
#define COLS (SIZE*SIZE)
byte levelPins[SIZE] = {11,12,13};

byte colPins[COLS] = {2,3,4,5,6,7,8,9,10};
LedCube cube(SIZE, levelPins, colPins);
//#define DEBUG
#ifdef DEBUG
#include <memdebug.h>
void showmem(const char label[] = "")
{
char buffer[100];
sprintf(buffer,"%s: %04u %04u %04u : used/free",

label,
getMemoryUsed(),
getFreeMemory()
);
Serial.println(buffer);
}
#endif
void setup ()
{
#ifdef DEBUG
Serial.begin(9600);
#endif
}
void loop ()
{
delay(10);
#ifdef DEBUG
Página 417/400
showmem("start");
#endif
cubeFrame* f[] = {
cube.createFrame((byte[]) {0,6, 1,6, 2,6}, 6, 80),
cube.createFrame((byte[]) {0,3, 1,3, 2,3}, 6, 10)
};
#ifdef DEBUG
showmem("before free");
#endif
cube.lightFrames(f, 8);
// light each light one at a time

for(byte level=0; level<cube.getLevels(); level++)
{
for(byte col=0; col<cube.getCols(); col++)
{
cube.lightPulse(level, col, 100);
}
}
// light one level at a time, increasing speed each time

for(byte d=25; d>2; d-=2)
{
for(byte l=1; l <= cube.getLevels(); l++)
{
cube.lightLevel(l, d);
}
}
// light each row on each level

for(byte level=1; level<=cube.getLevels(); level++)
{
for(byte row=1; row<=cube.getLevels()*2; row++)
{
cube.lightRow(row, level);
}
}
// light each plane
Página 418/400
for(byte i=3; i; i--)
{
for(byte row=1; row<=cube.getLevels()*2; row++)
{
cube.lightPlane(row, 10*i);
}
}
// single random light at a time

cube.randomLight(random(25,100),100);
// random column drop

for(byte x=0; x<=15; x++)
{
cube.lightDrop(random(0,cube.getCols()), random(50,150));
}
// circle around cube at a random level

for(byte x=0; x<=5; x++)
{
cube.lightPerimeter(random(0,cube.getLevels()), random(1,5), random(25,100));
}
// light each face

byte planes[] = {cube.getLevels()+1,cube.getLevels(),cube.getLevels()*2,1};
for(byte i=5; i; i--)
{
for(byte p=0; p<sizeof(planes); p++)
{
cube.lightPlane(planes[p], 5*i);
}
}
// random columns
cube.randomColumn(25);
// turn off a single column randomly

cube.enableBuffer();
for(byte c=0; c<30; c++)
{
cube.fillBuffer();
cube.invertBuffer();
cube.randomColumn();
cube.drawBuffer(7);
}
Página 419/400
cube.enableBuffer(false);
// cols in and out

for(byte c=1, d=0; c<=10; c++)
{
if(c%2 == 0)
{
for(d=0; d<20; d++)
{
cube.lightColumn(2,1);
}
}
else if(c%4 == 1)
{
for(d=0; d<30; d++)
{
}
}
else
{
for(d=0; d<70; d++)
{
}
}
}
// diamond and box

byte diamond[] = {0,4, 1,1, 1,3, 1,4, 1,5, 1,7, 2,4};
byte box[] = {
2,0, 2,1, 2,2, 2,3, 2,5, 2,6, 2,7, 2,8,
1,0, 1,2, 1,6, 1,8,
0,0, 0,1, 0,2, 0,3, 0,5, 0,6, 0,7, 0,8
};
cube.lightSequence(box, sizeof(box), 200);
cube.lightSequence(diamond, sizeof(diamond), 400);
// helicopter effect
Página 420/400
byte topSeq[8] = {0,3,6,7,8,5,2,1};
byte botSeq[8] = {8,5,2,1,0,3,6,7};
for(byte loops = 0, delay = 50; loops<=8; loops++)
{
for(byte s=0; s<8; s++)
{
byte seq[] = {2,topSeq[s], 1,4, 0,botSeq[s]};
cube.lightSequence(seq, sizeof(seq), delay);
}
if(loops < 5) delay-=10; else delay += 10;
}
// turn off one light at a time

cube.lightsOut();
}
Página 421/400
Actividad 9
Mostrar el funcionamiento de su trabajo al profesor, pues le deberá quedar
completamente claro el funcionamiento de su circuito.
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
APORTACIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
OPINIONES:
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
Página 422/400
Grado: _____________________ Grupo ____________________________
Actividad 10

Página 423/400
Anexo A
Tipografía de Reporte
Página 424/400
Anexo B Cronograma de Actividades
Página 425/400
Anexo C Normatividad
Normatividad. Forma de Evaluación.
—1) Guardar silencio en clase. 1) ASISTENCIA

—Esta calificación se determinará en base a la
—2) No entrar haciendo ruidos que distraiga a los asistencia presencial del alumno en clase mediante
demás o interrumpa la clase. el pase de lista y los trabajos en clase
desarrollados.
—3) Se pasara lista una vez por día a los 30 min.
después de la hora de entrada al salón. —2) ACTITUC Y PUNTUALIDAD
—Determinaremos la puntuación en base al
—4) Respeto a sus compañeros y/o al profesor respeto que el alumno muestre dentro del salón de
clase, al trabajar en equipo, hacia sus compañeros
—5) Tener más del 20% de faltas causa reprobar y el profesor, así como palabras anti sonantes.
el parcial con NP sin derecho a examen.
—3) OPINIONES EN CLASE
—6) A quien se le pida salir del salón por alguna —Deberán escribir UNA opinión por clase en su
falta a las normas será acreedor a la falta del día. cuaderno, la cual es un comentario ligero sobre los
temas de la clase, no se evalúa si es malo o bueno
—7) Podrán entrar a clase si llegan tarde solo si lo solo es una opinión. No menos de dos renglones.
hacen en silencio y sin distraer a los compañeros o
la clase con su debida falta. —4) APORTACIONES EN CLASE
—El alumno deberá aportar un conocimiento
—8) Las faltas se removerán si se presenta un adicional por cada clase recibida, dentro del tema
justificante oficial del departamento de servicios de clase el cual deberá ser cierto, ya bien por
escolares. haber estudiado, por alguna vivencia personal, o
lo ha probado por sí mismo. No menos de 2 dos
—9) Recordemos que el justificante justifica la renglones escritos en su cuaderno.
falta. EN NINGUN MOMENTO REMPLAZA
EXAMENES O TRABAJOS A ENTREGAR. —5) TRABAJOS EN CLASE
—El alumno deberá terminar los ejercicios solo en
—10) Al entregar el justificante debe este ser el horario de la clase dentro del salón, ya sea de
acompañado de los trabajos, tareas o forma individual o en equipo según aplique en el
investigaciones encargadas y de estar pendiente momento.
un examen se presentara el día que se presente el
justificante. —6) INVESTIGACIÓN Y/O PROYECTO
—Se le pide un trabajo de investigación de los
—11) Si el trabajo es por equipo y el equipo ya temas de la unidad o un proyecto por periodo de
presento el alumno deberá hacer su presentación evaluación. De ser investigación será calificado
SOLO, con el material necesario para ello. individualmente. De ser proyecto se calificara por
equipo
—12) Se les pide ser cuidadosos con los
justificantes, faltas, exámenes y trabajos —7) COMPLEMENTO APUNTES
extemporáneos, pues de presentarse después de —Se le otorgaran los puntos siempre que por cada
tiempo, cuando las calificaciones ya se registraron ejemplo o ejercicio desarrollado en clase el
en internet, ya no aplicara ninguna modificación. alumno desarrolle otro por cuenta propia, así
Por lo que se les pide estar pendientes de las mismo también deberá hacer anotaciones por lo
fechas límites de registro de calificaciones y explicado en clase profundizando el tema en
presentar su justificante, examen y/o trabajo antes cuestión.
de que se registre su calificación.
Nota: Sera una Practica por semana, No se —8) TAREA
aceptaran practicas fuera de tiempo, y no podrán —Se le indicara expresamente la tarea a entregar y
pasar a la siguiente hasta terminar la practica fechas límites, así como procedimientos y el
anterior
Página 426/400
objetivos muy bien definidos, esperado que
entregue un producto físico funcional.
—9) EXAMEN
—El examen podrá ser ORAL ó ESCRITO y El ALUMNO
constara en definir procedimientos, metodologías, En su libreta deberá tener:
formulas, conceptos y ejercicios vistos en clase y
que se encuentren dentro del temario de la materia Opiniones
con un tiempo límite de una hora para contestarlo Aportaciones
correctamente. Complemento a Apuntes
Tareas
—10) CASO TRABAJO EN EQUIPO Tabla de Evaluación
—En casos del trabajo en equipo, si algún Cronograma de Actividades
integrante no desarrolla su trabajo
correspondiente, los demás integrantes podrán En el manual de prácticas deberá tener:
indicarlo en su reporte por escrito, para de esta
forma calificarle por separado a su equipo. Trabajos en clase (Prácticas firmadas)
Reporte de Practicas Borrador
-11) CASO ESPECIAL SI NO CUMPLIÓ EN
TIEMPO Y FORMA. EL PROFESOR
—El profesor definirá procedimientos,
metodologías, conceptos y ejercicios que se Deberá tener en su lista:
encuentren dentro del temario, ASI COMO Asistencia
NUEVA FORMA DE EVALUAR al alumno Actitud y puntualidad
según su criterio, si aplica para otra oportunidad. Examen
—12) OTROS CASOS ESPECIALES Las fechas de evaluación serán las indicadas
—En casos no previstos el profesor procederá de forma oficial según el calendario vigente.
según su criterio.
Alumno:_____________________________
Lo que debo Recordar.
Datos del Padre o Tutor
Se pide una libreta única para la materia, la forma
tamaño color y costo no son importantes, solo que Fecha: ______________________________
sea única para la materia no compartir con otros
apuntes. Tomar en cuenta que se da una ventana Tutor:_______________________________
de tiempo de una semana para entregar sus
trabajos, exámenes, reporte, tareas, etc. todo lo Firma:________________________________
que tenga pendiente antes del registro de
calificaciones. Así mismo se otorgara la Enterado
calificación máxima para el día indicado, la cual
también dependerá de la calidad y funcionalidad TABLA DE EVALUACION
del trabajo entregado.
Página 427/400
Anexo Mapa Código de Colores de Resistencias
Página 428/400
Bibliografía.
Competencias SubMod Referencias
1 Utiliza equipo, 1 Norma Oficial Mexicana NOM-002-STPS-2000. Condiciones de

herramienta y seguridad, prevención, protección y combate de incendios en los
suministros en centros de trabajo.
circuitos eléctricos. NORMA Oficial Mexicana NOM-004-STPS-1999 Sistemas de
protección y dispositivos de seguridad en la maquinaria y equipo
que se utilice en los centros de trabajo.
NORMA Oficial Mexicana NOM-026-STPS-2008. Colores y
señales de seguridad e higiene, e identificación de riesgos por
fluidos conducidos en tuberías
2 Arma y comprueba 1 Zbar, P. (2006). Prácticas de electricidad. (7a Ed.). México.

circuitos empleados Alfaomega. P.5-35.
en sistemas eléctricos. Hermosa, A. (2003). Principios de electricidad y electrónica II. (1a
Ed.). España. Marcombo. P. 5-65.
Alldatasheets, sitio de búsqueda de hojas de datos de
componentes electrónicos. Consultado el 27 de Octubre de 2010,
de http://www.alldatasheet.com/Resistencias.
3 Energiza y opera 1 Norma Oficial Mexicana NOM-002-STPS-2000 Condiciones de
motores de CA, de CD seguridad, prevención, protección y combate de incendios en los
y relevadores. centros de trabajo.
Norma Oficial Mexicana NOM-004-STPS-1999 Sistemas de
protección y dispositivos de seguridad en la
maquinaria y equipo que se utilice en los centros de trabajo.
Norma Oficial Mexicana NOM-026-STPS-2008. Colores y
señales de seguridad e higiene, e identificación de riesgos por
fluidos conducidos en tuberías.
https://www.marcoteorico.com/
Página 429/400
Competencias SubMod Referencias
4 Arma y comprueba 2 García, C. (1997).Manejo del Osciloscopio Moderno.(1a Ed.).

circuitos básicos de México. Centro Japones de Información Electrónica
electrónica análoga. Datasheetscatalog, (2010). Fuente gratuita de hojas de datos para
componentes electrónicos y semiconductores. Consultado el 29
de mayo de 2010, de http://www.datasheetcatalog.com/
Alldatasheets, sitio de búsqueda de hojas de datos de
componentes electrónicos. Consultado el 27 de Octubre de 2010,
de http://www.alldatasheet.com/Resistencias
Worldwide supplier of high quality electronic components, (2010).
Proveedor mundial de componentes electrónicos de alta calidad.
Consultado el 14 de Junio de 2010, de
http://nte01.nteinc.com/nte/NTExRefSemiProd.nsf/$$Search
Malvino Albert, Bates David.(2007). Principios de electrónica. (7a
Ed.). México.Mc Graw Hill
Boylestad, R. (2004). Fundamentos de Eeectrónica. (2a. Ed.).
EUA. Prentice Hall
5 Arma y comprueba 2 Alldatasheets, sitio de búsqueda de hojas de datos de
circuitos básicos de componentes electrónicos. Consultado el 27 de Octubre de 2010,
electrónica digital. de http://www.alldatasheet.com/Resistencias
Angulo, J. (1996). Enciclopedia de electrónica moderna. (9a Ed.).
Madrid. Paraninfo.
Florez Fernández Héctor Arturo.(2010).Diseño lógico.
Fundamentos en electrónica digital.(1a Ed.). España. Ediciones de
la U., P.5-168
Boylestad, R. (2004). Fundamentos de Eeectrónica. (2a. Ed.).
EUA. Prentice Hall
Floyd, T. L..(2000).Fundamentos de sistemas digitales.(3a. Ed.).
EUA. Prentice Hall
Página 430/400

Practicas para Mecatronica Ene-Jun Semestre 4 Modulo 3 - Ver 2022

Cargado por

Información del documento

Título original

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

Practicas para Mecatronica Ene-Jun Semestre 4 Modulo 3 - Ver 2022

Cargado por

Copyright:

Formatos disponibles

CENTO DE BACHILLERATO TECNOLÓGICO

INDUSTRIAL Y DE SERVICIOS No. 47

Submódulo 1 - Programa controladores lógicos

Periodo Febrero –Junio 2022

La Reforma Integral de la Educación Media Superior se orienta a la construcción

La Coordinación Sectorial de Desarrollo Académico (CoSDAc), de la

Submódulo 1 - Programa controladores lógicos programables

Submódulo 2 - Instala y opera componentes de fuerza y actuadores

Submódulo 3 - Utiliza y programa tarjetas electrónicas de control.

- Podemos ver un ejemplo en la figura (3) de cómo debe quedar un circuito

Reglas Básicas Para la Construcción de un Diagrama de Flujo

El Microcontrolador vs el Microprocesador en esta entrada se establecerá una

Son dos los archivos que necesitaremos:

Ambos están incluidos en un archivo comprimido en Rar, que podrán obtener

Para la versión 7.X:

En un circuito integrado o chip se montan en un mismo componente varios

Recordando la unidad anterior veamos nuevamente el CI 555.

Armar la simulación siguiente:

Nombre del Alumno: _______________________________________________

Actividad 6).-Hacer su reporte a computadora siguiendo la tipografía indicada en el

El transistor consta de un sustrato (usualmente silicio) y tres partes dopadas

Primer transistor, consta de una base de germanio semiconductor, sobre la que se

La zona N con donantes de electrones (cargas negativas) y la zona P de

La configuración de uniones PN, dan como resultado transistores PNP o NPN,

Transistor de efecto de campo

El transistor de efecto campo es una familia de transistores que se basan en el

La mayoría de los FET están hechos usando las técnicas de procesado de

Un fototransistor es igual a un transistor común, con la diferencia que el primero

1.- Como transistor normal con la corriente de base Ib (modo común).

Se han utilizado en lectores de cinta y tarjetas perforadas, lápices ópticos, etc.

Se utilizan ampliamente encapsulados conjuntamente con un LED, formando

Un disipador es un componente metálico generalmente de aluminio que se utilizan

Tipos de transistores de potencia:

- Unipolar o Transistor de Efecto de Campo.

- IGBT (Transistor bipolar de puerta aislada).

¿Qué es un Circuito Codificador y que es un Circuito Decodificador?

Existen dos tipos fundamentales de codificadores: codificadores sin prioridad y

Dirección local de lugar.

En este caso, los codificadores son utilizados en archivos multimedia para

1. Decodificadores binarios básicos. Cuando se quiere determinar cuando por

2. El decodificador de 4 bits ó decodificador 1 de 16. Se utiliza para poder

4. Decodificadores BCD a 7 segmentos Es un circuito combinacional que permite

Básicamente el circuito consta de ocho entradas (x1 a x4, y1 a y4), donde

Tarea 1: Investigar sobre Programa de Simulación Proteus y Pic’s

Tiempo para desarrollo de Práctica

Lectura de Práctica y Análisis ----10 min

Tiempo total min 50 min máximo 60 min

Actividad 1 Verificar contar con su simulador ya instalado.

Programa para bajar el programa al el Pic

Esquema de conexionado con PIC aplica para los 5 programas.

' trisb=0 'poner puerto b como salida

Grado: _____________________ Grupo ____________________________

Nombre del Profesor: ________________________________________________

Firma del Profesor: ___________________ Fecha: ______________________

Hacer su reporte a computadora siguiendo la tipografía indicada en el Anexo A de

La Actividad 10 será su calificación correspondiente al punto Proyecto Y/O

Tarea 1: Investigar sobre Programa de Instalación Arduino

Tiempo para desarrollo de Práctica

Lectura de Práctica y Análisis ----10 min

Tiempo total min 60 min máximo 110 min

Actividad 1 Verificar contar con todo su material.

Organigrama y esquema de conexionado con la tarjeta Arduino

Grado: _____________________ Grupo ____________________________

Grado: _ Grupo ________

Firma del Profesor: _ Fecha: ____

Grado: _ Grupo ________

Firma del Profesor: _ Fecha: ____

Grado: _ Grupo ________

Firma del Profesor: _ Fecha: ____

Grado: _ Grupo ________

Firma del Profesor: _ Fecha: ____

Grado: _ Grupo ________

Firma del Profesor: _ Fecha: ____

Grado: _ Grupo ________

Firma del Profesor: _ Fecha: ____

Grado: _ Grupo ________

Firma del Profesor: _ Fecha: ____

Grado: _ Grupo ________

Firma del Profesor: _ Fecha: ____