MINISTERIO DE EDUCACIÓN

DIRECCIÓN DEPARTAMENTAL DE EDUCACIÓN LA PAZ

MÓDULO TECNOLÓGICO PRODUCTIVO EL ALTO
ESPECIALIDAD: ELECTRÓNICA Y SISTEMAS INFORMÁTICOS

AUTOMATIZACIÓN DE CIRCUITOS BENEFICIOSOS PARA

EL MÓDULO TECNOLÓGICO PRODUCTIVO “EL ALTO”
Proyecto de Grado Técnico de Innovación para obtener el grado de
Técnico Medio
POR: Bryan Paul Patty Tancara
Tania Huaycho Fernandez
Adal Abel Ulloa Callisaya
Diego Elvis Bautista Huanca
TUTOR: M. SC. BANHER VLADIMIR CHAMBI QUISPE
EL ALTO – BOLIVIA
2022
DIRECCIÓN GENERAL DE EDUCACIÓN GENERAL TÉCNICA, TECNOLÓGICA, LINGÜÍSTICA Y ARTÍSTICA
RESOLUCIÓN MINISTERIAL N° 847/201
La Paz - Bolivia
MÓDULO TECONOLÓGICO PRODUCTIVO EL ALTO
Acta de defensa de proyecto de grado Técnico
En la ciudad de El Alto, La Paz del Estado Plurinacional de Bolivia, en
instalaciones de la dirección del Módulo tecnológico productivo de El Alto, en
fechas 28 de octubre del 2022, se procede a la revisión y defensa de proyecto de
grado técnico titulado:

“AUTOMATIZACIÓN DE CIRCUITOS BENEFICIOSOS PARA EL MÓDULO

TECNOLÓGICO PRODUCTIVO “EL ALTO” ”

Presentado por el equipo comunitario de trabajo de grado:

 Tania Huaycho Fernandez.

 Bryan Paul Patty Tancara
 Adal Abel Ulloa Callisaya
 Diego Elvis Bautista Huanca

Inscritos en la especialidad de ELECTRÓNICA Y SISTEMAS INFORMÁTICOS,

aprobados en la modalidad de graduación de PROYECTO DE GRADO TÉCNICO.
Culminada la revisión del tribunal designado, le otorga las calificaciones de
……………………………….. puntos correspondientes a …………………...

Para constancia firma el tribunal el presente documento en los tres ejemplares, en

cumplimiento a la normativa legales de la Ley Avelino Siñani y Elizardo Pérez.

El Alto, 28 de octubre de 2022

NOMBRE Y FIRMA, TRIBUNAL REVISOR 1 NOMBRE Y FIRMA, TRIBUNAL REVSOR 2

NOMBRE Y FIRMA, TRIBUNAL REVISOR 3

Escala de calificación
< a 51 INSUFICIENTE
51 – 79 BUENA
80 – 89 SOBRESALIENTE
90 – 100 EXCELENTE

Dirección: Zona Santiago II Calle 12 Entre calle “E” y calle “F” Email:modulotecnologicoelalto@gmail.com
Teléfonos de contacto: 65561015 - 7629269
 DEDICATORIA

Dedicada al Módulo Tecnológico

Productivo “El Alto”, a la
sociedad alteña para continuar
innovando y creciendo.

I
 AGRADECIMIENTO
Agradecemos a nuestro docente por la
amplia información que nos ha
brindado y llenado de conocimiento.
Asimismo, agradecemos a la
tecnología por su aporte para realizar
distintas investigaciones.

II
INDICE
1. CAPITULO I: INTRODUCCIÓN ....................................................................................... 1
1.1. MARCO CONTEXTUAL ............................................................................................... 2
1.1.1. Datos referenciales del Contexto ..................................................................................... 2
1.1.2. Localización de proyecto .................................................................................................. 5
2. CAPITULO II: PLANTEAMIENTO DEL PROYECTO ...................................................... 7
2.1. Descripción del problema ............................................................................................. 7
2.2. Objetivos ...................................................................................................................... 7
2.2.1. Objetivo General .............................................................................................................. 7
2.2.2. Objetivos Específicos ........................................................................................................ 7
2.3. Límites y Alcances del proyecto o propuesta ............................................................... 8
2.4. Justificación Social ....................................................................................................... 8
2.5. Justificación Técnica .................................................................................................... 8
3. CAPITULO III: PROPUESTA DE INNOVACION DEL PROYECTO. ............................. 10
3.1. Antecedentes históricos ............................................................................................. 10
3.2. Marco teórico ............................................................................................................. 11
3.2.1 ¿Qué es Software? ................................................................................................................ 11
3.2.2 ¿Qué es Hardware? ............................................................................................................... 11
3.2.3.¿Qué es la automatización? .................................................................................................. 12
3.2.4.¿Qué significa inalámbrico? .................................................................................................. 12
3.2.5. ¿Qué es una placa Arduino?................................................................................................. 13
3.2.6. ¿Para qué sirve Arduino? ..................................................................................................... 14
3.2.7. Programación en Arduino .................................................................................................... 15
3.2.8. Módulo Bluetooth ................................................................................................................ 37
3.2.9. Modulo RTC 1307 ................................................................................................................. 39
3.3. Definición del proyecto ............................................................................................... 41
3.4. Diseño o planteamiento del proyecto ......................................................................... 41
3.5. Insumos, Materiales y Herramientas .......................................................................... 49
3.6. Procedimiento ............................................................................................................ 50
3.7. Valoración .................................................................................................................. 50
3.8. Costos y presupuesto................................................................................................. 51
4. CAPITULO IV: CONCLUSIONES Y RECOMENDACIONES ........................................ 52
4.1. Conclusiones.............................................................................................................. 52

III
4.2. Recomendaciones ..................................................................................................... 52
5. BIBLIOGRAFÍA Y WEBGRAFÍA ................................................................................... 54
6. ANEXOS ....................................................................................................................... 55

ÍNDICE GRÁFICO

Figura 1: Modulo Tecnológico Productivo “El Alto” ..................................................... 6

Figura 2: Observación del problema. .......................................................................... 9

Figura 3: Dificultades obtenidas gracias a los rayos solares. ..................................... 9

Figura 4: Partes de una placa Arduino...................................................................... 15

Figura 5: Módulo Bluetooth HC-05............................................................................ 39

Figura 6: Módulo RTC 130 ....................................................................................... 41

Figura 7: Diafragma pictográfico ............................................................................... 48

Figura 8: Diafragma esquemático ............................................................................. 49

Figura 9: Diseño de la app en “App inventor”. .......................................................... 50

IV
1. CAPITULO I: INTRODUCCIÓN

Hoy en día, con el avance de la tecnología ́ se observa que el ser humano busca
constantemente optimizar y satisfacer necesidades diarias.

Las cortinas automáticas serán para la automatización del modelo tecnológico

productivo y dar una mejor forma de iluminación cuando sea requerida y en cualquier
momento y solo con un simple botón, esta se realizará en las especialidades de
electrónica y sistemas informáticos así lo podrán utilizar tanto los de turno mañana y
tarde.

Para la cortina también tuvimos que profundizar en algunos temas en especial para
así hacer o dar un resultado más prometedor y que esté a la altura de lo aprendido en
las especialidades.

La creación de estas cortinas va a representar o dar una prueba de todo lo aprendido

en las especialidades de electrónica , sistemas informáticos y demostrar que las
especialidades son muy importantes en el día a día que además se le puede dar
múltiples usos en la modernidad, queremos que este proyecto no solo sirva para las
ventanas sino un incentivo más para que la siguiente generación de electrónica y
sistemas informáticos puedan apreciar que con los suficientes conocimientos se puede
inventar y crear casi cualquier cosa que se imaginen y que ellos mismos inventen
nuevos dispositivos electrónicos para hacer más fácil la vida de las personas que traten
de cambiar el mundo que nos rodea con sus ideas .

1
 1.1. MARCO CONTEXTUAL

1.1.1. Datos referenciales del Contexto

a) Geográfica.

El Gobierno Municipal de El Alto, es capital de la cuarta sección de la provincia Murillo

del Departamento de La Paz, está dividido en 14 Distritos Municipales, de los cuáles
uno es rural, el perfil geográfico muestra una ligera pendiente continua que desciende
de norte a sur, la altitud sobre el nivel del mar varía entre 4.150 m.s.m. (Milluni) y 4010
m.s.m. (Khenko), la posición geográfica es de 16°30¨latitud sur y 68 ° 12´ longitud
oeste. (Ver ANEXO A)

El Módulo Tecnológico productivo El Alto es el primer Módulo BTH del Departamento

de La Paz, ubicado en la ciudad de El Alto y se encuentra en la zona Santiago II, en la
calle 12 entre las calles “E” y “F”. Ésta es una de las zonas más antiguas de ex mineros
relocalizados, densamente poblada, por la presencia de centros comerciales, tiendas
de comercio, hospital, farmacias, modulo policial, unidad educativa, mercado, plazas,
centros culturales, espacios recreativos como parques y canchas polifuncionales con
una concurrencia masiva de gente procedente de áreas mineras y rural como de la
misma ciudad de El Alto y otros departamentos.

Los distritos municipales 1 y 2 de El Alto, sector de la Ceja de El Alto, son los más
poblados y donde están establecidos los centros comerciales de gran concurrencia de
este municipio. El distrito municipal 1 (de los 848.452 habitantes que tiene todo El Alto)
cuenta con 87.997 habitantes; el distrito 2 con 73.939 habitantes, La densidad es
significativa ante un promedio de El Alto que alcanza a 18,45 por Km2. (Fuente: Censo
de población y vivienda INE. 2012).

b) Cultural.

El distrito municipal 2, está conformada por personas de orígenes culturales como el

aymara y el quechua, pese a que un 27,9 por ciento de su población no se considera
pertenecer a ningún pueblo originario.

Respecto a los padres de familia que son parte del Módulo tecnológico Productivo El
Alto, en la formación Técnica Tecnológica Productiva, se tiene una percepción

2
generalizada de que ellos comprenden y hablan la lengua Castellana, de la misma
manera hay una buena cantidad de personas que hacen uso del quechua y aymara
como una lengua originaria.

c) Socio – económica.

La base económica de sus pobladores, donde está ubicado el MTPEA, es

principalmente el comercio legal establecido, porque existen tiendas y almacenes
comerciales y otros de amplia concurrencia que muestran su establecimiento formal;
por otro, existe también una proporción considerable de comercio informal en la calle
manifestada en las ventas de diferentes productos en puestos fijos y ambulantes; de
la misma manera se percibe el trabajo formal, porque vive gente que trabaja en bancos,
empresas y entidades dependientes del Estado como ONGs.

Los estudiantes, a quienes brinda cobertura el Módulo Tecnológico Productivo El Alto,

son a los estudiantes de los colegios de secundaria como: U.E. Bolívar municipal Don
Bosco, U.E. Unión Europea, U.E. Eduardo Abaroa Tarde, U.E. Villa el Carmen, U.E.
Horizontes B, U.E. Unión Bolivariana, U.E. República de Cuba Pacajes. Como se verá
proceden de diferentes zonas de la ciudad de El Alto, cuya matriculación se justifica
precisamente porque sus padres están vinculados a las diferentes formas de vida
como del comercio asentados en lo que se denomina la zona Santiago II de El Alto.
También existe un porcentaje importante de estudiantes que trabajan en horas libres
y estudian en el turno alterno.

d) En lo Institucional.

El Módulo Tecnológico Productivo El Alto, viene funcionando bajo la Resolución

Ministerial No 847/2019 de 02 de agosto de 2019 con las especialidades del área de
Técnica Tecnológica Especializada, del BTH, en Turismo y Hotelería, Electrónica,
Textiles y Tejidos, Gastronomía y Construcción Civil, en TTE – BTH, al servicio de los
estudiantes de Educación Secundaria Comunitaria Productiva como Fiscal y/o Estatal.

e) Recursos humanos

El Módulo Tecnológico Productivo El Alto cuenta con: 1 Rector, 1 Directora Académica,

1 Director Administrativo, 1 secretaria, 1 Asistente administrativo, 1 portero y 10
3
docentes 100% profesionales de las diferentes especialidades y 1002 estudiantes
entre varones mujeres desde 5to y 6to de Educación Secundaria en la formación TTE
- BTH, el día de la graduación se les hará la entrega del certificado de egreso y la
Diploma de bachiller en humanidades, como El Título de Técnico Medio.

f) Pedagógico

Para la concentración de los planes y programas, El Módulo Tecnológico Productivo

El Alto, desarrolla sus actividades bajo las siguientes modalidades:

MODALIDAD DE APRENDIZAJE: REGULAR en TTE – BTH

MODALIDAD DE LENGUAJE: MONOLINGUE

MODALIDAD DE DOCENCIA: UNIDOCENTE

MODALIDAD DE ATENCION: PRESENCIAL

De La enseñanza y aprendizaje de los educandos, gozan de una formación Técnica –

Tecnológica, Productiva, desarrollando capacidades técnicas tecnológicas como de su
personalidad y formación en valores socio comunitarios; por lo que el rendimiento
escolar es eficiente en la formación de c0onocimientos para la vida y sobre todo
óptimas y eficiente.

Los materiales escolares didácticos se utilizan de acuerdo a cada especialidad y de

acuerdo a sus necesidades y a su medio natural de esa manera se va cumpliendo el
programa; el cual significa la puntualidad responsabilidad, limpieza y el cumplimiento
de toda la comunidad del MTPEA durante la presente gestión.

Hacer hincapié la participación activa de todos los educandos, padres de familia y

docentes en las diferentes actividades como ser: FERIAS de EMPRENDIMIENTO
PRODUCTIVO y otros, donde los estudiantes aplican en forma práctica los
conocimientos adquiridos. Además, se solucionan diversos problemas de orden
técnico pedagógico en consejo de docentes, lo que faculta a su vez que las
experiencias adquiridas permitan llegar a uniformar el trabajo escolar.

4
En lo técnico pedagógico está se desarrolla desde el plan anual de actividades
pedagógicas, bajo un calendario escolar que es emanada desde las autoridades del
ramo educativo. Para posteriormente el MTPEA, ser parte activa desde la planificación
de las actividades curriculares de todo el proceso educativo, con la finalidad de formar
y transformar integral y holísticamente a los estudiantes, bajo los lineamientos de la
ley educativa 070 de Avelino Siñani – Elizardo Pérez.

g) Infraestructura.

El Módulo Tecnológico Productivo “El Alto” cuenta con: Infraestructura y equipamiento

propio de acuerdo al siguiente detalle.

3 direcciones para Rectorado, Dirección Académica y Dirección Administrativo

1 ambiente para la secretaria

1 ambiente de sala de Reuniones

1 sala Múltiple y Cocineta.

2 ambientes amplias para Gastronomía con depósito y su equipamiento.

2 ambientes amplias para Transformación de alimentos y depósitos con equipamiento.

1 galpón amplio y dos aulas para Construcción Civil, con equipamiento.

2 ambientes de Turismo y Hotelería con equipamiento.

4 ambientes dos talleres y dos laboratorios con equipamiento para Electrónica.

4 ambientes o galpones para textiles y tejidos con equipamiento.

1 galpón y aulas para la especialidad de Gestión de Riesgo. Con equipamiento.

4 ambientes para contabilidad con material correspondiente.

4 ambientes entre dos laboratorios y dos talleres para Sistemas Informáticos.

1.1.2. Localización de proyecto

DEPARTAMENTO: La Paz

5
MUNICIPIO: El Alto

DISTRITO EDUCATIVO: El Alto 2

INSTITUCIÓN EDUCATIVA: Módulo Tecnológico Productivo “El Alto”

NIVELES DE COBERTURA: 5to. Y 6to de educación Secundaria en TTE.

GESTIÓN ESCOLAR: 2022

CARRERA: ELECTRÓNICA Y SISTEMAS INFORMATICOS

Figura 1: Modulo Tecnológico Productivo “El Alto”

Fuente: https://www.facebook.com/TecnologicoElAlto

6
2. CAPITULO II: PLANTEAMIENTO DEL PROYECTO

2.1. Descripción del problema

Un problema llegaría a ser la falta o carencia de automatización en el módulo

tecnológico para diferentes acciones que pueden llegar a sintetizarse y hacerse de una
manera más eficaz o simple.

En este caso , observamos que el MTPEA carece de cortinas, probablemente

irrelevante para muchas personas, sin embargo es algo necesario para las aulas,
muchos docentes y estudiantes están disgustos por la falta de estos, estamos
conscientes de que la tecnología avanzó bastante y además de que ahora se volvió
parte de la metodología de enseñanza, por ejemplo algunos docentes usan el
proyector o data show, y las clases son dadas de día y la luz solar es molesto durante
las clases para los estudiantes y docentes, por lo tanto parte de este proyecto está
planteado para brindar una mejor comodidad para poder pasar las clases
correspondientes. Por otro lado, no fue la única carencia encontrada, notamos que el
MTPEA no cuenta con un timbre/alarma que indique los horarios de ingreso, receso y
salida, por lo tanto, lo incluimos a nuestro proyecto, para una mejor organización de
horarios, y más efectivo que indicarlo aula por aula.

Además de que sea muy beneficioso para el MTPEA, también es algo que la sociedad
e instituciones pueden ocupar.

2.2. Objetivos

2.2.1. Objetivo General

 Crear, elaborar e innovar proyectos beneficiosos para el MTPEA
mediante la automatización de circuitos.

2.2.2. Objetivos Específicos

 Elaborar y diseñar una aplicación para la utilización de las cortinas y
timbre/alarmas automáticas.
 Diseñar y desarrollar el software.
 Diseñar e implementar el hardware.
 Realizar pruebas de operación.

7
  Construir una estructura que se maneje de forma tanto alámbrica
como inalámbrica y simple.
 Socializar y demostrar el funcionamiento de dichos proyectos.

2.3. Límites y Alcances del proyecto o propuesta

Queremos que este proyecto de las cortinas automáticas sea de gran utilidad para la
especialidad de Sistemas Informáticos-Electrónica y así también presentar un proyecto
de calidad que sea de uso diario, esto será posible a la unión de las especialidades de
sistemas informáticos y electrónica que tiene el conocimiento necesario para hacerlo
realidad.

2.4. Justificación Social

Queremos que nuestro proyecto de las cortinas automáticas haga más simple la acción
de cerrar las cortinas del salón y no solo solucionar este tema sino darle un toque más
agradable al ambiente de trabajo con cortinas. También una mejor organización al
momento de indicar los horarios de ingreso, receso y salida.

2.5. Justificación Técnica

Luego de observar los ambientes del Módulo Tecnológico Productivo El Alto, notamos
que las aulas no cuentan con cortinas, muchos de los docentes trabajan con proyector
de pantalla, sin embargo, la luz no permite una buena proyección, dejando de lado
nuestro instituto, las personas necesitan un proyecto como el que realizamos, podría
ser de gran ayuda para las personas con alguna discapacidad que no son capaces de
pararse para quitarse una molestia (la luz) o al contrario. Además, actualizar los
ambientes académicos de nuestro MTPEA como también otros ambientes académicos
de El Alto-Bolivia.

8
Figura 2: Observación del problema.

Fuente: Propio.

Figura 3: Dificultades obtenidas gracias a los rayos solares.

Fuente: Propio.

9
3. CAPITULO III: PROPUESTA DE INNOVACION DEL PROYECTO.

3.1. Antecedentes históricos

Los ambientes académicos han ido evolucionando más y más, el papel de la educación
en la sociedad ha cambiado debido al surgimiento de paradigmas y nuevas
mediaciones que exigen las tecnologías de la información y la comunicación. Los
ambientes de aprendizaje, entendidos como los espacios en los cuales se desarrollan
los procesos de enseñanza y de aprendizaje, también están evolucionando de forma
rápida y efectiva. Las nuevas generaciones son afectadas cada vez desde más
temprana edad, por la inclusión de las diferentes tecnologías en su vida cotidiana. La
transformación de los ambientes de enseñanza y de aprendizaje es una necesidad
clara en el país.

Actualmente en nuestros ambientes académicos se vio la carencia de cortinas y

alarma/timbre. Sabemos que:

-Los timbres/alarmas fueron creados y utilizados con el objetivo de indicar horarios a

una cantidad grande de personas de una manera organizada.

-Las cortinas fueron creadas y utilizadas con el propósito de evitar los rayos solares.
Recolectamos estas ideas para añadir la automatización de circuitos y hacerlos más
eficientes para el MTPEA. Nuestro objetivo

Por lo tanto, nuestra propuesta pretende innovar continuando y aprovechando el

avance de la tecnología, aplicando la domótica, automatizando circuitos para elaborar
y diseñar proyectos que nos brinden más comodidad e nuestros ambientes
académicos.

En el MTPEA no se han presentado proyectos similares hasta el momento, sin

embargo, queremos inspirar a los futuros estudiantes a continuar innovando y creando
proyectos realmente útiles.

10
 3.2. Marco teórico

3.2.1 ¿Qué es Software?

• Sistema operativo de red: Permite la interconexión de ordenadores para

acceder a los servicios y recursos. Al igual que un equipo no puede trabajar sin un

sistema operativo, una red de equipos no puede funcionar sin un sistema

operativo de red. En muchos casos el sistema operativo de red es parte

del sistema operativo de los servidores y de los clientes.

• Software de aplicación: En última instancia, todos los elementos se utilizan

para que el usuario de cada estación, pueda utilizar sus programas y archivos

específicos. Este software puede ser tan amplio como se necesite ya que puede

incluir procesadores de texto, paquetes integrados, sistemas administrativos de

contabilidad y áreas afines, sistemas especializados, correos electrónicos, etc. El

software adecuado en el sistema operativo de red elegido y con los protocolos

necesarios permiten crear servidores para aquellos servicios que se necesiten.

3.2.2 ¿Qué es Hardware?

Para lograr el enlace entre las computadoras y los medios de transmisión (cables

de red o medios físicos para redes alámbricas e infrarrojos o radiofrecuencias para

redes inalámbricas), es necesaria la intervención de una tarjeta de

red (NIC, Network Card Interface), con la cual se puedan enviar y recibir paquetes

de datos desde y hacia otras computadoras, empleando un protocolo para su

comunicación y convirtiendo a esos datos a un formato que pueda ser transmitido

por el medio (bits, ceros y unos). Cabe señalar que a cada tarjeta de red le es

11
asignado un identificador único por su fabricante, conocido como dirección

MAC (Media Access Control), que consta de 48 bits (6 bytes). Dicho identificador

permite direccionar el tráfico de datos de la red del emisor al receptor adecuado.

El trabajo del adaptador de red es el de convertir las señales eléctricas que viajan

por el cable (p.e.: red Ethernet) o las ondas de radio (p.e.: red Wi-Fi) en una señal

que pueda interpretar el ordenador.

3.2.3.¿Qué es la automatización?

“La automatización consiste en usar la tecnología para realizar tareas con muy poca
intervención humana. Se puede implementar en cualquier sector en el que se lleven
a cabo tareas repetitivas.”

En palabras más llanas se podría decir que la automatización es la forma de hacer

más eficaz o simple una acción que se repite a diario como ser el hecho de abrir las
ventanas o las cortinas cada mañana haciendo que esta tarea sea aburrida y una
odisea por la mañana.

3.2.4.¿Qué significa inalámbrico?

La principal diferencia entre estas es que la red cableada se conecta mediante cables
de datos (Ethernet), y la red inalámbrica no se conecta físicamente, sino que utiliza
ondas electromagnéticas para transmitir la información necesaria.

Una red inalámbrica conecta las computadoras sin utilizar cables de red. Los equipos
utilizan comunicaciones por radio para enviar datos entre sí. Puede comunicarse
directamente con otras computadoras inalámbricas o conectarse a una red.

12
A través de estas redes o ondas es posible enviar señales a dispositivos lejanos o que
no están al alcance así pudiendo los controlar a gusto en cualquier momento y lugar
que desees.

3.2.5. ¿Qué es una placa Arduino?

Arduino, es una plataforma de hardware open-source basada en placas programables

para crear dispositivos digitales con ellos. Actualmente hay varios modelos de placas
Arduino en el mercado, con diferentes formatos de tamaño, diferentes procesadores,
conectores, capacidades… pero todas ellas tienen en común que cuentan con un
procesador programable con su memoria RAM y hasta almacenamiento flash, unos
pines de entrada y salida para la comunicación con otros dispositivos, sensores o
elementos de forma analógica o digital y alguna forma de conexión por USB o similar
para poder programar el dispositivo y que puede servir también para alimentarlo,
Aunque hay modelos que cuentan con otras formas de alimentación. Todas estas
capacidades hacen posible que estas pequeñas placas puedan cargar código desde
un ordenador y ejecutarlo incluso de forma autónoma siempre que tengan una fuente
de alimentación, lo cual permite darle una gran variedad de usos a estas placas,
pudiendo incluso combinar varias entre sí para poder crear circuitos más complejos.

El proyecto de Arduino nació en 2005 con el único objetivo de proveer a los estudiantes
del “Interaction Design Institute Ivrea” de una placa o sistema electrónico que
permitiera a cualquier tipo de persona ya sea estudiante o profesional, crear
dispositivos digitales que pudieran interactuar con el entorno mediante sensores como
micrófonos o detectores de movimiento, y a la vez poder también generar una
respuesta visible mediante diodos leds o motores u otros medios. Todo esto siempre
intentando hacerlo con el menor coste posible y de la forma más simple, lo cual permite
hacer dispositivos simples como termostatos, y también dispositivos más complejos
como robots con varias funciones. El nombre del proyecto también proviene de la
misma universidad, más concretamente de un bar donde los fundadores solían quedar,

13
el cual se llamaba “Arduin of Ivrea” en honor a quien fue rey de Italia entre los años
1002 y 1014.

3.2.6. ¿Para qué sirve Arduino?

Las placas electrónicas de Arduino tienen prácticamente infinitas aplicaciones y formas

de usarse, ya que están creadas precisamente para que sean completamente
polivalentes, decidiendo cada uno para qué las quiere usar dependiendo del código
que cree y de los elementos y el circuito al cual conecte la placa. Aparte de los usos,
las placas Arduino puede adoptar también infinitas formas debido al formato open-
source del proyecto, de forma que cualquier compañía puede hacer copias de las
placas Arduino, venderlas y hacer sus propias modificaciones al diseño original de las
placas, los cuales por cierto están incluso publicados en internet para que cualquiera
pueda consultarlos. Por esa misma razón podremos encontrar todo tipo de placas
programables basadas en los diseños de Arduino de todos los colores y tipos, siendo
la única condición que para esas placas que no lance la propia marca Arduino no se
use su nombre, el cual solo aparecerá en las placas que sean “oficiales”.

La propia marca tiende varios modelos en su pagina web, con diferentes variantes y
revisiones, siendo el más popular el Arduino Uno, que es la placa más todo terreno,
con un buen número de conectores y hasta opción de wifi. Por otro lado, estarían las
Nano, la versión más pequeña de la familia, la cual tiene varias variantes con sensores
dedicados y sirve para tener una placa programable de un tamaño de apenas
45x18mm. Justo en el extremo opuesto estaría la Arduino Mega, con chips más
potentes y con muchísimos más conectores, casi cuadriplicando los de una placa Uno,
lo cual la hace perfecta para proyectos complejos con un montón de elementos.
También, aparte de las placas para poder sacarlas partido necesitaremos elementos
externos como cables, diodos, motores, sensores y demás para que la placa pueda
hacer algo, ya que por sí solas la mayoría de ellas serán solo un procesador
programable, sin ningún sensor que procesar ni formas por las que interactuar con el
entorno.

14
Figura 4: Partes de una placa Arduino.

Fuente: https://aprendiendoarduino.wordpress.com/tag/esquemas-electricos/

3.2.7. Programación en Arduino

La estructura básica del lenguaje de programación de Arduino es bastante simple

y se compone de al menos dos partes. Estas dos partes necesarias, o funciones,
encierran bloques que contienen declaraciones, estamentos o instrucciones.

void setup()
{
estamentos;
} void loop()

15
 {
estamentos;
}

En donde setup() es la parte encargada de recoger la configuración y loop() es la

que contienen el programa que se ejecutará cíclicamente (de ahí el termino loop –
bucle-). Ambas funciones son necesarias para que el programa trabaje.

La función de configuración debe contener la declaración de las variables. Es la

primera función a ejecutar en el programa, se ejecuta sólo una vez, y se utiliza
para configurar o inicializar pinMode (modo de trabajo de las E/S), configuración
de la comunicación en serie y otras.

La función bucle (loop) siguiente contiene el código que se ejecutara

continuamente (lectura de entradas, activación de salidas, etc) Esta función es el
núcleo de todos los programas de Arduino y la que realiza la mayor parte del
trabajo.

setup()

La función setup() se invoca una sola vez cuando el programa empieza. Se utiliza
para inicializar los modos de trabajo de los pins, o el puerto serie. Debe ser incluido
en un programa aunque no haya declaración que ejecutar.

void setup()
{
pinMode(pin, OUTPUT); // configura el 'pin' como salida
}

16
 loop()

Después de llamar a setup(), la función loop() hace precisamente lo que sugiere

su nombre, se ejecuta de forma cíclica, lo que posibilita que el programa este
respondiendo continuamente ante los eventos que se produzcan en la tarjeta

void loop()
{
digitalWrite(pin, HIGH); // pone en uno (on, 5v) el ´pin´
delay(1000); // espera un segundo (1000 ms)
digitalWrite(pin, LOW); // pone en cero (off, 0v.) el ´pin´
delay(1000);
}

funciones

Una función es un bloque de código que tiene un nombre y un conjunto de

estamentos que son ejecutados cuando se llama a la función. Son funciones
setup() y loop() de las que ya se ha hablado. Las funciones de usuario pueden ser
escritas para realizar tareas repetitivas y para reducir el tamaño de un programa.
Las funciones se declaran asociadas a un tipo de valor “type”. Este valor será el
que devolverá la función, por ejemplo 'int' se utilizará cuando la función devuelva
un dato numérico de tipo entero. Si la función no devuelve ningún valor entonces
se colocará delante la palabra “void”, que significa “función vacía”. Después de
declarar el tipo de dato que devuelve la función se debe escribir el nombre de la
función y entre paréntesis se escribirán, si es necesario, los parámetros que se
deben pasar a la función para que se ejecute.

17
 type nombreFunción(parámetros)
{
estamentos;
}

La función siguiente devuelve un número entero, delayVal() se utiliza para poner

un valor de retraso en un programa que lee una variable analógica de un
potenciómetro conectado a una entrada de Arduino. Al principio se declara como
una variable local, ´v´ recoge el valor leído del potenciómetro que estará
comprendido entre 0 y 1023, luego se divide el valor por 4 para ajustarlo a un
margen comprendido entre 0 y 255, finalmente se devuelve el valor ´v´ y se
retornaría al programa principal. Esta función cuando se ejecuta devuelve el valor
de tipo entero ´v´

int delayVal()
{
int v; // crea una variable temporal 'v' v=
analogRead(pot); // lee el valor del potenciómetro v /= 4;
// convierte 0-1023 a 0-255 return v; // devuelve el
valor final
}

{} entre llaves

Las llaves sirven para definir el principio y el final de un bloque de instrucciones.

Se utilizan para los bloques de programación setup(), loop(), if.., etc.

type funcion()

18
 {
estamentos;
}

Una llave de apertura “{“ siempre debe ir seguida de una llave de cierre “}”, si no
es así el programa dará errores.

El entorno de programación de Arduino incluye una herramienta de gran utilidad

para comprobar el total de llaves. Sólo tienes que hacer click en el punto de
inserción de una llave abierta e inmediatamente se marca el correspondiente cierre
de ese bloque (llave cerrada).

; punto y coma

El punto y coma “;” se utiliza para separar instrucciones en el lenguaje de

programación de Arduino. También se utiliza para separar elementos en una
instrucción de tipo “bucle for”.

int x = 13; // declara la variable 'x' como tipo entero de valor 13

Nota: Olvidarse de poner fin a una línea con un punto y coma se traducirá en un
error de compilación. El texto de error puede ser obvio, y se referirá a la falta de
una coma, o puede que no. Si se produce un error raro y de difícil detección lo
primero que debemos hacer es comprobar que los puntos y comas están
colocados al final de las instrucciones.

/*… */ bloque de comentarios

19
Los bloques de comentarios, o multi-línea de comentarios, son áreas de texto
ignorados por el programa que se utilizan para las descripciones del código o
comentarios que ayudan a comprender el programa. Comienzan con / * y terminan
con * / y pueden abarcar varias líneas.

/* esto es un bloque de comentario no

se debe olvidar cerrar los comentarios
estos deben estar equilibrados */
Debido a que los comentarios son ignorados por el programa y no ocupan espacio
en la memoria de Arduino pueden ser utilizados con generosidad y también pueden
utilizarse para "comentar" bloques de código con el propósito de anotar
informaciones para depuración.

Nota: Dentro de una misma línea de un bloque de comentarios no se puede escribir

otra bloque de comentarios (usando /* .. */ )

// línea de comentarios

Una línea de comentario empieza con / / y terminan con la siguiente línea de

código. Al igual que los comentarios de bloque, los de línea son ignoradas por el
programa y no ocupan espacio en la memoria.

// esto es un comentario

Una línea de comentario se utiliza a menudo después de una instrucción, para

proporcionar más información acerca de lo que hace esta o para recordarla más
adelante.

20
 variables

Una variable es una manera de nombrar y almacenar un valor numérico para su

uso posterior por el programa. Como su nombre indica, las variables son números
que se pueden variar continuamente en contra de lo que ocurre con las constantes
cuyo valor nunca cambia. Una variable debe ser declarada y, opcionalmente,
asignarle un valor. El siguiente código de ejemplo declara una variable llamada
variableEntrada y luego le asigna el valor obtenido en la entrada analógica del
PIN2:

int variableEntrada = 0; // declara una variable y le asigna el valor 0

variableEntrada = analogRead(2);// la variable recoge el valor analógico del PIN2

'variableEntrada' es la variable en sí. La primera línea declara que será de tipo

entero “int”. La segunda línea fija a la variable el valor correspondiente a la entrada
analógica PIN2. Esto hace que el valor de PIN2 sea accesible en otras partes del
código.

Una vez que una variable ha sido asignada, o re-asignada, usted puede probar su
valor para ver si cumple ciertas condiciones (instrucciones if..), o puede utilizar
directamente su valor. Como ejemplo ilustrativo veamos tres operaciones útiles
con variables: el siguiente código prueba si la variable “entradaVariable” es inferior
a 100, si es cierto se asigna el valor 100 a “entradaVariable” y, a continuación,
establece un retardo (delay) utilizando como valor “entradaVariable” que ahora
será como mínimo de valor 100:

if (entradaVariable < 100) // pregunta si la variable es menor de 100

{

21
 entradaVariable = 100;// si es cierto asigna el valor 100 a esta
}
delay(entradaVariable); // usa el valor como retardo

Nota: Las variables deben tomar nombres descriptivos, para hacer el código más
legible. Nombres de variables pueden ser “contactoSensor” o “pulsador”, para
ayudar al programador y a cualquier otra persona a leer el código y entender lo
que representa la variable. Nombres de variables como “var” o “valor”, facilitan muy
poco que el código sea inteligible. Una variable puede ser cualquier nombre o
palabra que no sea una palabra reservada en el entorno de Arduino.

declaración de variables

Todas las variables tienen que declararse antes de que puedan ser utilizadas. Para
declarar una variable se comienza por definir su tipo como int (entero), long (largo),
float (coma flotante), etc, asignándoles siempre un nombre, y, opcionalmente, un
valor inicial. Esto sólo debe hacerse una vez en un programa, pero el valor se
puede cambiar en cualquier momento usando aritmética y reasignaciones
diversas.

El siguiente ejemplo declara la variable entradaVariable como una variable de tipo

entero “int”, y asignándole un valor inicial igual a cero. Esto se llama una
asignación.

int entradaVariable = 0;

Una variable puede ser declarada en una serie de lugares del programa y en
función del lugar en donde se lleve a cabo la definición esto determinará en que
partes del programa se podrá hacer uso de ella.

22
 Utilización de una variable

Una variable puede ser declarada al inicio del programa antes de la parte de
configuración setup(), a nivel local dentro de las funciones, y, a veces, dentro de
un bloque, como para los bucles del tipo if.. for.., etc. En función del lugar de
declaración de la variable así se determinara el ámbito de aplicación, o la
capacidad de ciertas partes de un programa para hacer uso de ella.

Una variable global es aquella que puede ser vista y utilizada por cualquier función
y estamento de un programa. Esta variable se declara al comienzo del programa,
antes de setup().

Una variable local es aquella que se define dentro de una función o como parte de
un bucle. Sólo es visible y sólo puede utilizarse dentro de la función en la que se
declaró.

Por lo tanto, es posible tener dos o más variables del mismo nombre en diferentes
partes del mismo programa que pueden contener valores diferentes. La garantía
de que sólo una función tiene acceso a sus variables dentro del programa simplifica
y reduce el potencial de errores de programación.

El siguiente ejemplo muestra cómo declarar a unos tipos diferentes de variables y

la visibilidad de cada variable:

int value; // 'value' es visible para cualquier función void

setup()
23
 {
// no es necesario configurar }

void loop()
{ for (int i=0; i<20;) // 'i' solo es visible
{ // dentro del bucle for i++;
} float f; // 'f' es visible
solo
} // dentro del bucle
byte

Byte almacena un valor numérico de 8 bits sin decimales. Tienen un rango entre 0
y 255

byte unaVariable = 180; // declara 'unaVariable' como tipo byte

Int

Enteros son un tipo de datos primarios que almacenan valores numéricos de 16

bits sin decimales comprendidos en el rango 32,767 to -32,768.

int unaVariable = 1500; // declara 'unaVariable' como una variable de

tipo entero

Nota: Las variables de tipo entero “int” pueden sobrepasar su valor máximo o
mínimo como consecuencia de una operación. Por ejemplo, si x = 32767 y una
posterior declaración agrega 1 a x, x = x + 1 entonces el valor se x pasará a ser -
32.768. (algo así como que el valor da la vuelta)

24
 long

El formato de variable numérica de tipo extendido “long” se refiere a números

enteros (tipo 32 bits) sin decimales que se encuentran dentro del rango -
2147483648 a 2147483647.

long unaVariable = 90000; // declara 'unaVariable' como tipo long

float

El formato de dato del tipo “punto flotante” “float” se aplica a los números con
decimales. Los números de punto flotante tienen una mayor resolución que los de
32 bits con un rango comprendido 3.4028235E +38 a +38-3.4028235E.

float unaVariable = 3.14; // declara 'unaVariable' como tipo flotante

Nota: Los números de punto flotante no son exactos, y pueden producir resultados
extraños en las comparaciones. Los cálculos matemáticos de punto flotante son
también mucho más lentos que los del tipo de números enteros, por lo que debe
evitarse su uso si es posible.

operadores lógicos

Los operadores lógicos son usualmente una forma de comparar dos expresiones
y devolver un VERDADERO o FALSO dependiendo del operador. Existen tres
operadores lógicos, AND (&&), OR (||) y NOT (!), que a menudo se utilizan en
estamentos de tipo if..:

Logical AND:
if (x > 0 && x < 5) // cierto sólo si las dos expresiones son ciertas

25
 Logical OR:
if (x > 0 || y > 0) // cierto si una cualquiera de las expresiones es
cierta

Logical NOT:
if (!x > 0) // cierto solo si la expresión es falsa

constantes

El lenguaje de programación de Arduino tiene unos valores predeterminados, que

son llamados constantes. Se utilizan para hacer los programas más fáciles de leer.
Las constantes se clasifican en grupos.

cierto/falso (true/false)

Estas son constantes booleanas que definen los niveles HIGH (alto) y LOW (bajo)
cuando estos se refieren al estado de las salidas digitales. FALSE se asocia con 0
(cero), mientras que TRUE se asocia con 1, pero TRUE también puede ser
cualquier otra cosa excepto cero. Por lo tanto, en sentido booleano, -1, 2 y -200
son todos también se define como TRUE. (esto es importante tenerlo en cuanta)

if (b == TRUE);
{
ejecutar las instrucciones;
}

26
high/low

Estas constantes definen los niveles de salida altos o bajos y se utilizan para la
lectura o la escritura digital para las patillas. ALTO se define como en la lógica de
nivel 1, ON, ó 5 voltios, mientras que BAJO es lógica nivel 0, OFF, o 0 voltios.

digitalWrite(13, HIGH); // activa la salida 13 con un nivel alto (5v.)

input/output

Estas constantes son utilizadas para definir, al comienzo del programa, el modo de
funcionamiento de los pines mediante la instrucción pinMode de tal manera que el
pin puede ser una entrada INPUT o una salida OUTPUT.

pinMode(13, OUTPUT); // designamos que el PIN 13 es una salida

if (si)

if es un estamento que se utiliza para probar si una determinada condición se ha

alcanzado, como por ejemplo averiguar si un valor analógico está por encima de
un cierto número, y ejecutar una serie de declaraciones (operaciones) que se
escriben dentro de llaves, si es verdad. Si es falso (la condición no se cumple) el
programa salta y no ejecuta las operaciones que están dentro de las llaves, El
formato para if es el siguiente:

27
 if (unaVariable ?? valor)
{
ejecutaInstrucciones;
}

En el ejemplo anterior se compara una variable con un valor, el cual puede ser una
variable o constante. Si la comparación, o la condición entre paréntesis se cumple
(es cierta), las declaraciones dentro de los corchetes se ejecutan. Si no es así, el
programa salta sobre ellas y sigue.

Nota: Tenga en cuenta el uso especial del símbolo '=', poner dentro de if (x = 10),
podría parecer que es valido pero sin embargo no lo es ya que esa expresión
asigna el valor 10 a la variable x, por eso dentro de la estructura if se utilizaría
X==10 que en este caso lo que hace el programa es comprobar si el valor de x es
10.. Ambas cosas son distintas por lo tanto dentro de las estructuras if, cuando se
pregunte por un valor se debe poner el signo doble de igual “==”

if… else (si….. sino ..)

if… else viene a ser un estructura que se ejecuta en respuesta a la idea “si esto no
se cumple haz esto otro”. Por ejemplo, si se desea probar una entrada digital, y
hacer una cosa si la entrada fue alto o hacer otra cosa si la entrada es baja, usted
escribiría que de esta manera:

if (inputPin == HIGH) // si el valor de la entrada inputPin es alto

{
instruccionesA; //ejecuta si se cumple la condición

28
 } else
{ instruccionesB; //ejecuta si no se cumple la condición

Else puede ir precedido de otra condición de manera que se pueden establecer

varias estructuras condicionales de tipo unas dentro de las otras (anidamiento) de
forma que sean mutuamente excluyentes pudiéndose ejecutar a la vez. Es incluso
posible tener un número ilimitado de estos condicionales. Recuerde sin embargo
qué sólo un conjunto de declaraciones se llevará a cabo dependiendo de la
condición probada:

if (inputPin < 500)

{
instruccionesA; // ejecuta las operaciones A
} else if (inputPin >=
1000)
{ instruccionesB; // ejecuta las operacione B

} else
{ instruccionesC; // ejecuta las operaciones C

Nota: Un estamento de tipo if prueba simplemente si la condición dentro del

paréntesis es verdadera o falsa. Esta declaración puede ser cualquier declaración
válida. En el anterior ejemplo, si cambiamos y ponemos (inputPin == HIGH). En
este caso, el estamento if sólo chequearía si la entrada especificado esta en nivel
alto (HIGH), o +5 v.

for

29
La declaración for se usa para repetir un bloque de sentencias encerradas entre
llaves un número determinado de veces. Cada vez que se ejecutan las
instrucciones del bucle se vuelve a testear la condición. La declaración for tiene
tres partes separadas por (;) vemos el ejemplo de su sintaxis:

for (inicialización; condición; expresión)

{
ejecutaInstrucciones;
}

La inicialización de una variable local se produce una sola vez y la condición se

testea cada vez que se termina la ejecución de las instrucciones dentro del bucle.
Si la condición sigue cumpliéndose, las instrucciones del bucle se vuelven a
ejecutar. Cuando la condición no se cumple, el bucle termina.

El siguiente ejemplo inicia el entero i en el 0, y la condición es probar que el valor

es inferior a 20 y si es cierto i se incrementa en 1 y se vuelven a ejecutar las
instrucciones que hay dentro de las llaves:

for (int i=0; i<20; i++) // declara i, prueba que es menor que
20, incrementa i en 1
{
digitalWrite(13, HIGH); // envía un 1 al pin 13 delay(250);
// espera ¼ seg.
digitalWrite(13, LOW); // envía un 0 al pin 13
delay(250); // espera ¼ de seg.
}

30
Nota: El bucle en el lenguaje C es mucho más flexible que otros bucles encontrados
en algunos otros lenguajes de programación, incluyendo BASIC. Cualquiera de los
tres elementos de cabecera puede omitirse, aunque el punto y coma es obligatorio.
También las declaraciones de inicialización, condición y expresión puede ser
cualquier estamento válido en lenguaje C sin relación con las variables declaradas.
Estos tipos de estados son raros pero permiten disponer soluciones a algunos
problemas de programación raras.

while

Un bucle del tipo while es un bucle de ejecución continua mientras se cumpla la

expresión colocada entre paréntesis en la cabecera del bucle. La variable de
prueba tendrá que cambiar para salir del bucle. La situación podrá cambiar a
expensas de una expresión dentro el código del bucle o también por el cambio de
un valor en una entrada de un sensor

while (unaVariable ?? valor)

{
ejecutarSentencias;
}

El siguiente ejemplo testea si la variable "unaVariable” es inferior a 200 y, si es

verdad, ejecuta las declaraciones dentro de los corchetes y continuará ejecutando
el bucle hasta que 'unaVariable' no sea inferior a 200.

While (unaVariable < 200) // testea si es menor que 200

{
instrucciones; // ejecuta las instrucciones entre
llaves unaVariable++; // incrementa la variable en 1

31
 }

do… while

El bucle do while funciona de la misma manera que el bucle while, con la salvedad
de que la condición se prueba al final del bucle, por lo que el bucle siempre se
ejecutará al menos una vez.

do
{
Instrucciones;
} while (unaVariable ?? valor);

El siguiente ejemplo asigna el valor leído leeSensor() a la variable 'x', espera 50

milisegundos, y luego continua mientras que el valor de la 'x' sea inferior a 100:

do
{ x = leeSensor();
delay(50);
} while (x < 100);

pinMode(pin, mode)

Esta instrucción es utilizada en la parte de configuración setup () y sirve para

configurar el modo de trabajo de un PIN pudiendo ser INPUT (entrada) u OUTPUT
(salida).

32
pinMode(pin, OUTPUT); // configura ‘pin’ como salida

Los terminales de Arduino, por defecto, están configurados como entradas, por lo
tanto no es necesario definirlos en el caso de que vayan a trabajar como entradas.
Los pines configurados como entrada quedan, bajo el punto de vista eléctrico,
como entradas en estado de alta impedancia.

Estos pines tienen a nivel interno una resistencia de 20 KΩ a las que se puede
acceder mediante software. Estas resistencias se accede de la siguiente manera:

pinMode(pin, INPUT); // configura el ‘pin’ como entrada digitalWrite(pin,

HIGH); // activa las resistencias internas

Las resistencias internas normalmente se utilizan para conectar las entradas a

interruptores. En el ejemplo anterior no se trata de convertir un pin en salida, es
simplemente un método para activar las resistencias interiores.

Los pins configurado como OUTPUT (salida) se dice que están en un estado de
baja impedancia estado y pueden proporcionar 40 mA (miliamperios) de corriente
a otros dispositivos y circuitos. Esta corriente es suficiente para alimentar un diodo
LED (no olvidando poner una resistencia en serie), pero no es lo suficiente grande
como para alimentar cargas de mayor consumo como relés, solenoides, o motores.

Un cortocircuito en las patillas Arduino provocará una corriente elevada que puede
dañar o destruir el chip Atmega. A menudo es una buena idea conectar en la
OUTUPT (salida) una resistencia externa de 470 o de 1000 Ω.

digitalRead(pin)

33
Lee el valor de un pin (definido como digital) dando un resultado HIGH (alto) o LOW
(bajo). El pin se puede especificar ya sea como una variable o una constante (0-
13).

valor = digitalRead(Pin); // hace que 'valor sea igual al estado leído

en ´Pin´

digitalWrite(pin, value)

Envía al ´pin´ definido previamente como OUTPUT el valor HIGH o LOW (poniendo
en 1 o 0 la salida). El pin se puede especificar ya sea como una variable o como
una constante (0-13).

digitalWrite(pin, HIGH); // deposita en el 'pin' un valor HIGH (alto o 1)

El siguiente ejemplo lee el estado de un pulsador conectado a una entrada digital

y lo escribe en el ´pin´de salida LED:

int led = 13; // asigna a LED el valor 13

int boton = 7; // asigna a botón el valor 7
int valor = 0; // define el valor y le asigna el valor
0

void setup()
{

34
 pinMode(led, OUTPUT); // configura el led (pin13) como salida
pinMode(boton, INPUT); // configura botón (pin7) como entrada
}

void loop()
{ valor = digitalRead(boton); //lee el estado de la entrada botón
digitalWrite(led, valor); // envía a la salida ´led´el valor leído }

analogRead(pin)

Lee el valor de un determinado pin definido como entrada analógica con una
resolución de 10 bits. Esta instrucción sólo funciona en los pines (0-5). El rango de
valor que podemos leer oscila de 0 a 1023.

valor = analogRead(pin); // asigna a valor lo que lee en la entrada

´pin'

Nota: Los pins analógicos (0-5) a diferencia de los pines digitales, no necesitan ser
declarados como INPUT u OUPUT ya que son siempre INPUT´s.

analogWrite(pin, value)

Esta instrucción sirve para escribir un pseudo-valor analógico utilizando el

procedimiento de modulación por ancho de pulso (PWM) a uno de los pin´s de
Arduino marcados como “pin PWM”. El más reciente Arduino, que implementa el
chip ATmega168, permite habilitar como salidas analógicas tipo PWM los pines 3,
5, 6, 9, 10 y 11. Los modelos de Arduino más antiguos que implementan el chip
ATmega8, solo tiene habilitadas para esta función los pines 9, 10 y 11. El valor que

35
se puede enviar a estos pines de salida analógica puede darse en forma de
variable o constante, pero siempre con un margen de 0-255.

analogWrite(pin, valor); // escribe 'valor' en el 'pin' definido como

analógico
Si enviamos el valor 0 genera una salida de 0 voltios en el pin especificado; un
valor de

255 genera una salida de 5 voltios de salida en el pin especificado. Para valores
de entre

0 y 255, el pin saca tensiones entre 0 y 5 voltios - el valor HIGH de salida equivale
a 5v

(5 voltios). Teniendo en cuenta el concepto de señal PWM , por ejemplo, un valor

de 64 equivaldrá a mantener 0 voltios de tres cuartas partes del tiempo y 5 voltios
a una cuarta parte del tiempo; un valor de 128 equivaldrá a mantener la salida en
0 la mitad del tiempo y 5 voltios la otra mitad del tiempo, y un valor de 192
equivaldrá a mantener en la salida 0 voltios una cuarta parte del tiempo y de 5
voltios de tres cuartas partes del tiempo restante.

Debido a que esta es una función de hardware, en el pin de salida analógica

(PWN) se generará una onda constante después de ejecutada la instrucción
analogWrite hasta que se llegue a ejecutar otra instrucción analogWrite (o una
llamada a digitalRead o digitalWrite en el mismo pin).

Nota: Las salidas analógicas a diferencia de las digitales, no necesitan ser

declaradas como INPUT u OUTPUT..

El siguiente ejemplo lee un valor analógico de un pin de entrada analógica,

convierte el valor dividiéndolo por 4, y envía el nuevo valor convertido a una salida
del tipo PWM o salida analógica:
36
 int led = 10; // define el pin 10 como ´led´
int analog = 0; // define el pin 0 como ´analog´
int valor; // define la variable ´valor´

void setup(){} // no es necesario configurar entradas y

salidas

void loop()
{
valor = analogRead(analog); // lee el pin 0 y lo asocia a la
variable valor
valor /= 4; / /divide valor entre 4 y lo reasigna a valor
analogWrite(led, value); // escribe en el pin10 valor }

delay(ms)

Detiene la ejecución del programa la cantidad de tiempo en ms que se indica en la

propia instrucción. De tal manera que 1000 equivale a 1seg.

delay(1000); // espera 1 segundo

3.2.8. Módulo Bluetooth

37
El Módulo Bluetooth HC-06 es un dispositivo que soporta conexiones inalámbricas a
través del protocolo “Bluetooth”.

Se pueden comportar como esclavo o maestro, lo que sirve para escuchar peticiones
de conexión y para generar peticiones de conexión. Si algún dispositivo se conecta, el
módulo transmite a este todos los datos que recibe desde un microcontrolador y
viceversa.

El módulo Bluetooth HC-06 dispone de 4 pines, solo puede actuar como esclavo,
dispone de un juego reducido de instrucciones a las que atiende, permite:

 Una conexión sencilla y sin problemas mediante comandos AT a través de una

puerta serie.
 La comunicación de voz y datos a través de una red inalámbrica llamada WPAN

Los módulos HC-06 están montados sobre una interfaz en la que se incluye cuatro
pines para su conexión, Vcc, Gnd, Txd y Rxd, además cuentan con un LED para indicar
el estado de conexión del Bluetooth; si el LED parpadea es que no está emparejado,
si este está activado de forma continua el Bluetooth esta emparejado.

El módulo HC-06 cumple con las especificaciones del estándar Bluetooth 2.0 a 2.4
GHz que es perfectamente compatible con Arduino y PIC, celulares o Smartphone
Android, más no con los IPhone.

Funciones

· Reemplaza un enlace serial cableado por un enlace inalámbrico en forma

transparente

· Posee el perfil Bluetooth "Wireless Serial Port"

· Se puede configurar como Master o Slave

· Ideal para controlar proyectos Arduino, PIC, Atmel, etc. en forma inalámbrica con la
PC

38
En la siguiente infografía se detallan elementos importantes.

Figura 5: Módulo Bluetooth HC-05

Fuente: https://aprendiendoarduino.wordpress.com/tag/hc-05/

3.2.9. Modulo RTC 1307

Los RTC (Real Time Clock) o reloj en Tiempo Real son la solución ideal cuando
necesitamos integrar mediciones de tiempo a nuestros proyectos. Los RTC son de
muy bajo consumo por lo que pueden ser alimentados por baterías y de esa forma no
perder la sincronización. Si bien los microcontroladores poseen contadores internos,
estos no son tan exactos como un RTC dedicado.

El módulo está basado en el RTC DS1307 de MAXIM y la EEPROM AT24C32 de

ATMEL. Ambos circuitos integrados comparten el mismo bus comunicación con
el Protocolo I2C. La memoria EEPROM AT24C32 te permite almacenar 32Kbits (4K
Bytes) de datos de manera permanente.

Una alternativa es el módulo RTC DS3231 que es la evolución del DS1307.

Funciones del RTC:

39
 Hora: Segundos, minutos, horas
 Fecha: número día, día de la semana, mes y año
 Compensación de año bisiesto
 Pin de salida a 1 Hz para llevar el tiempo en otros componentes

ESPECIFICACIONES TÉCNICAS

-Voltaje de alimentación: 3.3V - 5V DC

-Chips principales: DS1307 y AT24C32

-Interfaz de comunicación digital: I2C

-Dirección I2C del DS1307: Read(11010001) Write(11010000)

-Memoria EEPROM AT24C32 (4K * 8bit = 32Kbit = 4KByte)

-Puede ser usado en cascada con otro dispositivo I2C, la dirección del AT24C32
puede ser modificada (por defecto es 0x57)

-La batería puede mantener al RTC funcionando por 10 años.

-Dimensiones: 28*27 mm

-Peso: 5 gramos

CONEXIÓN

 SCL - A5
 SDA - A4
 VCC - 5V
 GND – GND

40
 Figura 6: Módulo RTC 1307

Fuente: https://www.youtube.com/watch?v=xTVGEdiaX3s

3.3. Definición del proyecto

El proyecto a presentar es una cortina y timbre/alarma automatizada que será utilizada

de forma inalámbrica mediante una aplicación que nosotros mismos crearemos, en el
aspecto de la cortina será realizada con un mecanismo de poleas y motorreductores
que harán el funcionamiento de la cortina para su movimiento. Tanto la cortina como
la alarma serán programadas en Arduino, y ambas tendrán su aplicación diseñada
para su funcionamiento inalámbrico.

3.4. Diseño o planteamiento del proyecto

Realizar una automatización de circuitos para mejorar una cortina simple y sencilla
como también el timbre/alarma. Todo será elaborado en el siguiente orden:

-Elaboración de códigos.

-Diseño de ambas app para el manejo inalámbrico de ambos.

41
-Pruebas en protoboard.

-Armado de ambas estructuras.

-Elaboración de ambas placas.

-Comprobar funcionamiento de ambas en sus estructuras.

Códigos:

CORTINAS

SoftwareSerial BT1 (2,3); //Tx , Rx

char vigila = 0;

int Mot1_izq = 4;

int Mot1_der = 5;

int btn1 = 6;

int btn2 = 7;

int btn3 = 8;

int Mot2_izq = 9;

int Mot2_der = 10;

void setup (){

Serial.begin(9600);

BT1.begin (9600);

pinMode (Mot1_izq, OUTPUT);

pinMode (Mot1_der, OUTPUT);

pinMode (Mot2_izq, OUTPUT);

42
pinMode (Mot2_der, OUTPUT);

pinMode (btn1, INPUT);

pinMode (btn2, INPUT);

pinMode (btn3, INPUT);

void loop (){

if (BT1.available ()){

vigila = BT1.read();

if (vigila == 'A'){

digitalWrite (Mot1_izq , 1); digitalWrite (Mot2_izq , 1);

digitalWrite (Mot1_der , 0); digitalWrite (Mot2_der , 0);

if (vigila == 'B'){

digitalWrite (Mot1_izq, 0); digitalWrite (Mot2_izq , 0);

digitalWrite (Mot1_der, 1); digitalWrite (Mot2_der , 1);

if (vigila == 'C'){

digitalWrite(Mot1_izq,0); digitalWrite (Mot2_izq , 0);

digitalWrite(Mot1_der,0); digitalWrite (Mot2_der , 0);

43
 }

if(digitalRead(btn1)== HIGH){

digitalWrite (Mot1_izq,1); digitalWrite (Mot2_izq , 1);

digitalWrite (Mot1_der,0); digitalWrite (Mot2_der , 0);

if(digitalRead(btn2)== HIGH){

digitalWrite (Mot1_izq , 0); digitalWrite (Mot2_izq , 0);

digitalWrite (Mot1_der , 1); digitalWrite (Mot2_der , 1);

if(digitalRead(btn3)== HIGH){

digitalWrite (Mot1_izq,0); digitalWrite (Mot2_izq , 0);

digitalWrite (Mot1_der,0); digitalWrite (Mot2_der , 0);

ALARMA
#include <SoftwareSerial.h> //libreria con las funciones para el modulo I2C
#include <LiquidCrystal_I2C.h> //libreria contiene funciones para la pantalla lcd con
extencion I2C
#include "RTClib.h" //libreria contiene funciones para el modulo RTC-1307
#include <Wire.h> //libreria que permite la comunicación I2C

RTC_DS1307 rtc; //creamos un objeto llamado "rtc" para el modulo RTC

44
LiquidCrystal_I2C lcd (0x27, 16 ,2); //creamos un objeto llamado "lcd" para el lcd
SoftwareSerial Bt1 (2,3); // Tx(2), Rx(3) //creamos un objeto llamado "Bt1"
int rele = 4; //definimos "led" con valor 4
char lectura = 0; //creamosuna variable tipo caracter llamado "lectura" con valor 0
void setup (){
Serial.begin(9600); //inicializamos la comunicaión Serial con 9600 baudios (bait por
segundo)
Bt1.begin(9600); //inicializamos la comunicación del modulo bluetooth con 9600
baudios (bait por segundo)
Wire.begin(); //configuramos la comunicación de las conexxiones I2C
lcd.init(); //inicializamos la pantalla LCD
lcd.backlight(); //damos inicio a la iluminación led de la pantalla LCD
pinMode (rele, OUTPUT); //configuramos el pin "rele" con salida de señal
if ( ! rtc.begin ()){ //preguntamos si el objeto rtc NO esta conectado
// en caso de NO esta conectado cumple las siguientes instrucciones
lcd.print ("SIN ACCESO"); //la pantalla LCD imprime el texto entre comillas
Serial.print("Modulo no encontrado"); //el monitor Serial imprime el texto entre
comillas
while (1); //mientras sea 1 no podremos continuar el código
}
//rtc.adjust(DateTime(2022, 10, 21, 6, 7, 0)); //iniciamos por unica vez la fecha del
modulo RTC

}
void loop(){

DateTime now = rtc.now(); // "now" es la que guardará los datos del tiempo

lcd.setCursor(0,1); //seleccionamos la columna (0) y la fila (1)

lcd.print(now.day());//imprimimos en la pantalla LCD el dia
lcd.print("/"); //imprimimos en la pantalla LCD el texto en comillas

45
 lcd.print(now.month()); //imprimimos en la pantalla LCD el mes
lcd.print("/"); //imprimimos en la pantalla LCD el texto entre comillas
lcd.print(now.year()); //imprimimos en la pantalla LCD el año mantenido por el modulo

lcd.setCursor (0,0);
lcd.print(now.hour()); //imprimimos en la pantalla LCD la hora sguida por el RTC
lcd.print(":"); //imprimimos en la pantalla LCD el texto
lcd.print(now.minute()); //imprimimos en la pantalla LCD el minuto correspondiente
lcd.print(":"); //imprimimos en la pantalla LCD el texto o simbolo
lcd.print(now.second()); //imprimimos en la pantalla LCD los segundos en los que se
encuentra el RTC
delay(1000); //detenemos el codigo 1000 milisegundos (1 segundo)
lcd.clear(); //mandamos la instruccion de limpiar la pantalla lcd completa
if (Bt1.available ()){ //preguntamos si el objeto "Bt1" tiene valores guardados
//si la condición se cumple se ejecutan las intrucciones siguientes
lectura = Bt1.read(); //las variable "lectura" es igual a la lectura del objeto "Bt1" o los
valores guardados por el modulo Bluetooth

//timbre enrada
if (lectura == 'A'){ //preguntsmos si la variable lectura es igual al caracter 'A'
digitalWrite (rele, HIGH); //ordenamos la escritura digital para el pin "rele"
encendido
lcd.setCursor (0,3); //seleccionamos la columna (0) y la fila (3) del LCD
lcd.print("Entrada"); //imprimimos el texto "Entrada" en la pantalla LCD
}
if(lectura == 'B'){ //preguntsmos si la variable lectura es igual al caracter 'B'
digitalWrite (rele,LOW); //ordenamos la escritura digital para el pin "rele" apagado
lcd.setCursor (0,3); //seleccionamos la columna (0) y la fila (3) del la pantalla LCD
lcd.print("Entrada"); //imprimimos el texto "Entrada" en la pantalla LCD
}

46
 //timbre del recreo
if (lectura == 'C'){ //preguntsmos si la variable lectura es igual al caracter 'C'
digitalWrite (rele, HIGH); //ordenamos la escritura digital para el pin "rele"
encendido
lcd.setCursor (0,3); //seleccionamos la columna (0) y la fila (3)
lcd.print("Recreo"); //imprimimos el texto "Recreo" en la pantalla LCD
}
if(lectura == 'D'){ //preguntsmos si la variable lectura es igual al caracter 'D'
digitalWrite (rele,LOW); //ordenamos la escritura digital para el pin "rele" en estado
bajo
lcd.setCursor (0,3); //seleccionamos la columna (0) y la fila (3) de la pantalla
display (LCD)
lcd.print("Recreo"); //imprimimos el texto "Recreo" en la pantalla LCD
}
if (lectura == 'E'){ //preguntsmos si la variable lectura es igual al caracter 'E'
digitalWrite (rele, HIGH); //ordenamos la escritura digital para el pin "rele"
encendido
lcd.setCursor (0,3); //seleccionamos la columna (0) y la fila (3)
lcd.print("Recreo"); //imprimimos el texto "Recreo" en la pantalla LCD
}
if(lectura == 'F'){ //preguntsmos si la variable lectura es igual al caracter 'F'
digitalWrite (rele,LOW); //ordenamos la escritura digital para el pin "rele" en estado
bajo
lcd.setCursor (0,3); //seleccionamos la columna (0) y la fila (3) de la pantalla
display (LCD)
lcd.print("Recreo"); //imprimimos el texto "Recreo" en la pantalla LCD

if (lectura == 'G'){ //preguntsmos si la variable lectura es igual al caracter 'G'

digitalWrite (rele, HIGH); //ordenamos la escritura digital para el pin "rele" en estado
alto

47
 lcd.setCursor (0,3); //seleccionamos la columna (0) y la fila (3) del LCD
lcd.print("Salida"); //imprimimos el texto "Salida" en la pantalla LCD
}
if(lectura == 'H'){ //preguntsmos si la variable lectura es igual al caracter 'H'
digitalWrite (rele,LOW); //ordenamos la escritura digital para el pin "rele" apagado
lcd.setCursor (0,3); //seleccionamos la columna (0) y la fila (3)
lcd.print("Salida"); //imprimimos el texto "Salida" en la pantalla LCD

}
}
}

Figura 7: Diafragma pictográfico.

Fuente: Propio.

48
Figura 8: Diafragma esquemático.

Fuente: Propio.

3.5. Insumos, Materiales y Herramientas

Los materiales necesarios y utilizados para este proyecto son:

-2 motorreductores
-2 finales de carrera
-1 RTC 1307
-2 rieles completos
-Polea
-2 docenas de ganchos de cortina
-Tubo PVC
-arduino
-Cables
-pulsadores
-Un celular
-placa de cobre

49
 3.6. Procedimiento

Como primer paso realizamos la elaboración de los códigos y diseño de ambas apps
utilizando MIT App inventor, luego comprobar el funcionamiento de estos, también
realizamos la parte física apoyados del protoboard para así luego pasarlo a una placa
de cobre, en la parte de la estructura será creada una vez que esté comprobado que
el proyecto funciona adecuadamente, utilizaremos rieles, poleas motorreductores y
distintos otros materiales para la elaboración de ambos proyectos.

Figura 9: Diseño de la app en “App inventor”.

Fuente: Propio.

3.7. Valoración

Los conocimientos y experiencias adquiridas durante el proceso de elaboración de

este proyecto fue algo muy interesante, ganamos experiencia además de ganar más
conocimiento.

Podemos destacar que ambos proyectos son bastantes beneficiosos para el MTPEA ,
y la sociedad, ya que creamos e innovamos con proyectos realmente útiles, aplicamos
de nuestros conocimientos para poder elaborar, diseñar y armar los proyectos (cortina
y alarma /timbre), a la vez continuamos creciendo y evolucionando junto con la

50
tecnología , a la vez queremos inspirar a más jóvenes para continuar creando,
creciendo e innovando.

3.8. Costos y presupuesto

UNIDAD COSTOS
CANTIDAD
N° DESCRIPCIÓN DE OBSERVACIONES
UTILIZADA UNITARIO TOTAL
MEDIDA
ARDUINOS 2 80 bs.
1

MÓDULO 2 45 90 bs
2
BLUETOOTH
MÓDULO 1 17 bs.
3
RELÉ
PANTALLA 1 25 bs
4
LCD
MÓDULO I2C 1 25 bs.
5

MÓDULO RTC 1 27 bs
6
1307
PUENTE 1 22 bs.
7
HL298N
RIELES DE 2 20 bs.
8
CORTINA
MOTOR 2 15 bs.
9
REDUCTOR
FINAL DE 2 5 bs
10
CARRERA
326 bs.
TOTAL

51
4. CAPITULO IV: CONCLUSIONES Y RECOMENDACIONES

4.1. Conclusiones

En conclusión, se concluye q el proyecto de grado ayude de alguna manera a la

especialidad de sistemas informáticos y a los demás estudiantes siendo q todo el
esfuerzo de electrónica y sistemas Informáticos fueron utilizados para realizar el
proyecto presentado.

El proyecto fue un gran reto para los de sistemas al tratar de realizar los diferentes
algoritmos no solo de Arduino si no de toda la aplicación q fue utilizada para controlar
de forma inalámbrica los diferentes aparatos electrónicos, como las cortinas y el
timbre.

La especialidad de sistemas tuvo un conocimiento limitado así q tuvimos q expandir

los datos y aplicaciones para poder realizar la aplicación y otros, en el proceso nos
dimos cuenta lo difícil q es aprender a programar sin saber cómo hacerlo, una ayuda
indispensable fue la del internet donde nos dieron una guía completa de como
aprender estos diferentes lenguajes de programación, para así llegar a este punto.

En un punto de vista electrónico, se logró cumplir con los objetivos propuestos, se logro
realizar un buen manejo de programación en Arduino, ampliando nuestros
conocimientos con distintas apps, como la App inventor, la elaboración del hardware
fue realizado de manera correcta, gracias a los conocimientos adquiridos no tuvimos
muchas dificultades al momento de elaborarlo.

4.2. Recomendaciones

Como estudiantes de las especialidades de sistemas informáticos y electrónica nos

dimos cuenta q el tiempo es fundamental para el proyecto tuvimos demasiados
tropiezos ya q siendo aun estudiantes en colegio no se encontraba tiempo para realizar
el proyecto por eso decidimos por optar en días clave y realizarlo en equipo de forma
q todos nos concentremos en el proyecto un día clave, aun así, superamos el reto.

52
otro problema q tuvimos fue la falta de información teníamos una gran idea, pero no
sabíamos como realizarlo así q nos apoyamos con ayuda del internet especialmente
en informática ya q el internet fue un apoyo casi completo al realizar nuestro proyecto
y los diferentes algoritmos.

Nos dimos cuenta q el trabajo en equipo es muy importante no solo por q nos
ayudamos entre especialidades si no q al momento en q no avanzábamos tuvimos q
compartir información y ayudarnos entre nosotros para poder superar esa barrera entre
nosotros así que lo más importante q podemos resaltar es q un proyecto en grupo debe
de ser unido.

Se recomienda lo siguiente:

-Tener amplio conocimiento de programación en Arduino.

-Tener cuidado con las polaridades al momento de pasarlo a protoboard.

-Manejar con cuidado todos los materiales.

-Organizar adecuadamente el tiempo de elaboración de proyecto.

53
5. BIBLIOGRAFÍA Y WEBGRAFÍA

Crespo, Enrique, Aprendiendo Arduino.

Obtenido de https://www.aprendiendoarduino.com, Consultado en: octubre 1, 2022.

FRITZING. 2022. https://fritzing.org/. Obtenido de https://fritzing.org/learning/

[consulta 1 de febrero de 2022]

KIO4. 2022. http://kio4.com/. Obtenido de

http://kio4.com/appinventor/0_presentacion.htm [consulta 2 de febrero de 2022]

ERRERO H J. C. y SÁNCHES ALLENDE, J. (2015). Una mirada al mundo de

Arduino. Tecnologí@ y Desarrolo , 1-28

54
6. ANEXOS

Anexo A: Modulo tecnológico Productivo El Alto

Anexo B: Elaboración de la estructura de la cortina.

55
Anexo C: Diseño de la app.

56